serverVariables) {
+ this.serverVariables = serverVariables;
+ return this;
+ }
+
+ /**
+ * Get HTTP client
+ *
+ * @return An instance of OkHttpClient
+ */
+ public OkHttpClient getHttpClient() {
+ return httpClient;
+ }
+
+ /**
+ * Set HTTP client, which must never be null.
+ *
+ * @param newHttpClient An instance of OkHttpClient
+ * @return ApiClient
+ * @throws java.lang.NullPointerException when newHttpClient is null
+ */
+ public ApiClient setHttpClient(OkHttpClient newHttpClient) {
+ this.httpClient = Objects.requireNonNull(newHttpClient, "HttpClient must not be null!");
+ return this;
+ }
+
+ /**
+ * Get JSON
+ *
+ * @return JSON object
+ */
+ public JSON getJSON() {
+ return json;
+ }
+
+ /**
+ * Set JSON
+ *
+ * @param json JSON object
+ * @return Api client
+ */
+ public ApiClient setJSON(JSON json) {
+ this.json = json;
+ return this;
+ }
+
+ /**
+ * True if isVerifyingSsl flag is on
+ *
+ * @return True if isVerifySsl flag is on
+ */
+ public boolean isVerifyingSsl() {
+ return verifyingSsl;
+ }
+
+ /**
+ * Configure whether to verify certificate and hostname when making https requests.
+ * Default to true.
+ * NOTE: Do NOT set to false in production code, otherwise you would face multiple types of cryptographic attacks.
+ *
+ * @param verifyingSsl True to verify TLS/SSL connection
+ * @return ApiClient
+ */
+ public ApiClient setVerifyingSsl(boolean verifyingSsl) {
+ this.verifyingSsl = verifyingSsl;
+ applySslSettings();
+ return this;
+ }
+
+ /**
+ * Get SSL CA cert.
+ *
+ * @return Input stream to the SSL CA cert
+ */
+ public InputStream getSslCaCert() {
+ return sslCaCert;
+ }
+
+ /**
+ * Configure the CA certificate to be trusted when making https requests.
+ * Use null to reset to default.
+ *
+ * @param sslCaCert input stream for SSL CA cert
+ * @return ApiClient
+ */
+ public ApiClient setSslCaCert(InputStream sslCaCert) {
+ this.sslCaCert = sslCaCert;
+ applySslSettings();
+ return this;
+ }
+
+ /**
+ * Getter for the field keyManagers.
+ *
+ * @return an array of {@link javax.net.ssl.KeyManager} objects
+ */
+ public KeyManager[] getKeyManagers() {
+ return keyManagers;
+ }
+
+ /**
+ * Configure client keys to use for authorization in an SSL session.
+ * Use null to reset to default.
+ *
+ * @param managers The KeyManagers to use
+ * @return ApiClient
+ */
+ public ApiClient setKeyManagers(KeyManager[] managers) {
+ this.keyManagers = managers;
+ applySslSettings();
+ return this;
+ }
+
+ /**
+ * Get TLS server name for SNI (Server Name Indication).
+ *
+ * @return The TLS server name
+ */
+ public String getTlsServerName() {
+ return tlsServerName;
+ }
+
+ /**
+ * Set TLS server name for SNI (Server Name Indication).
+ * This is used to verify the server certificate against a specific hostname
+ * instead of the hostname in the URL.
+ *
+ * @param tlsServerName The TLS server name to use for certificate verification
+ * @return ApiClient
+ */
+ public ApiClient setTlsServerName(String tlsServerName) {
+ this.tlsServerName = tlsServerName;
+ applySslSettings();
+ return this;
+ }
+
+ /**
+ * Getter for the field dateFormat.
+ *
+ * @return a {@link java.text.DateFormat} object
+ */
+ public DateFormat getDateFormat() {
+ return dateFormat;
+ }
+
+ /**
+ * Setter for the field dateFormat.
+ *
+ * @param dateFormat a {@link java.text.DateFormat} object
+ * @return a {@link {{invokerPackage}}.ApiClient} object
+ */
+ public ApiClient setDateFormat(DateFormat dateFormat) {
+ JSON.setDateFormat(dateFormat);
+ return this;
+ }
+
+ /**
+ * Set SqlDateFormat.
+ *
+ * @param dateFormat a {@link java.text.DateFormat} object
+ * @return a {@link {{invokerPackage}}.ApiClient} object
+ */
+ public ApiClient setSqlDateFormat(DateFormat dateFormat) {
+ JSON.setSqlDateFormat(dateFormat);
+ return this;
+ }
+
+ {{#joda}}
+ public ApiClient setDateTimeFormat(DateTimeFormatter dateFormat) {
+ JSON.setDateTimeFormat(dateFormat);
+ return this;
+ }
+
+ public ApiClient setLocalDateFormat(DateTimeFormatter dateFormat) {
+ JSON.setLocalDateFormat(dateFormat);
+ return this;
+ }
+
+ {{/joda}}
+ {{#jsr310}}
+ /**
+ * Set OffsetDateTimeFormat.
+ *
+ * @param dateFormat a {@link java.time.format.DateTimeFormatter} object
+ * @return a {@link {{invokerPackage}}.ApiClient} object
+ */
+ public ApiClient setOffsetDateTimeFormat(DateTimeFormatter dateFormat) {
+ JSON.setOffsetDateTimeFormat(dateFormat);
+ return this;
+ }
+
+ /**
+ * Set LocalDateFormat.
+ *
+ * @param dateFormat a {@link java.time.format.DateTimeFormatter} object
+ * @return a {@link {{invokerPackage}}.ApiClient} object
+ */
+ public ApiClient setLocalDateFormat(DateTimeFormatter dateFormat) {
+ JSON.setLocalDateFormat(dateFormat);
+ return this;
+ }
+
+ {{^isJackson}}{{! Jackson has no LocalDateTime adapter to reconfigure; Gson and JSON-B do. }}
+ /**
+ * Set LocalDateTimeFormat.
+ *
+ * @param dateFormat a {@link java.time.format.DateTimeFormatter} object
+ * @return a {@link {{invokerPackage}}.ApiClient} object
+ */
+ public ApiClient setLocalDateTimeFormat(DateTimeFormatter dateFormat) {
+ JSON.setLocalDateTimeFormat(dateFormat);
+ return this;
+ }
+
+ {{/isJackson}}
+ {{/jsr310}}
+ {{^isJsonb}}{{! JSON-B has no equivalent of Gson's lenient mode or Jackson's ALLOW_* read features. }}
+ /**
+ * Set LenientOnJson.
+ *
+ * @param lenientOnJson a boolean
+ * @return a {@link {{invokerPackage}}.ApiClient} object
+ */
+ public ApiClient setLenientOnJson(boolean lenientOnJson) {
+ JSON.setLenientOnJson(lenientOnJson);
+ return this;
+ }
+
+ {{/isJsonb}}
+
+ /**
+ * Get authentications (key: authentication name, value: authentication).
+ *
+ * @return Map of authentication objects
+ */
+ public Map 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);
+ }
+
+ {{#hasHttpBearerMethods}}
+ /**
+ * Helper method to set access token for the first Bearer authentication.
+ * @param bearerToken Bearer token
+ */
+ public void setBearerToken(String bearerToken) {
+ setBearerToken(() -> bearerToken);
+ }
+
+ /**
+ * Helper method to set the supplier of access tokens for Bearer authentication.
+ *
+ * @param tokenSupplier The supplier of bearer tokens
+ */
+ public void setBearerToken(Supplier tokenSupplier) {
+ for (Authentication auth : authentications.values()) {
+ if (auth instanceof HttpBearerAuth) {
+ ((HttpBearerAuth) auth).setBearerToken(tokenSupplier);
+ return;
+ }
+ }
+ throw new RuntimeException("No Bearer authentication configured!");
+ }
+ {{/hasHttpBearerMethods}}
+
+ /**
+ * Helper method to set username for the first HTTP basic authentication.
+ *
+ * @param username Username
+ */
+ public void setUsername(String username) {
+ for (Authentication auth : authentications.values()) {
+ if (auth instanceof HttpBasicAuth) {
+ ((HttpBasicAuth) auth).setUsername(username);
+ return;
+ }
+ }
+ throw new RuntimeException("No HTTP basic authentication configured!");
+ }
+
+ /**
+ * Helper method to set password for the first HTTP basic authentication.
+ *
+ * @param password Password
+ */
+ public void setPassword(String password) {
+ for (Authentication auth : authentications.values()) {
+ if (auth instanceof HttpBasicAuth) {
+ ((HttpBasicAuth) auth).setPassword(password);
+ return;
+ }
+ }
+ 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 void setApiKey(String apiKey) {
+ for (Authentication auth : authentications.values()) {
+ if (auth instanceof ApiKeyAuth) {
+ ((ApiKeyAuth) auth).setApiKey(apiKey);
+ return;
+ }
+ }
+ 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 void setApiKeyPrefix(String apiKeyPrefix) {
+ for (Authentication auth : authentications.values()) {
+ if (auth instanceof ApiKeyAuth) {
+ ((ApiKeyAuth) auth).setApiKeyPrefix(apiKeyPrefix);
+ return;
+ }
+ }
+ throw new RuntimeException("No API key authentication configured!");
+ }
+
+ /**
+ * Helper method to set access token for the first OAuth2 authentication.
+ *
+ * @param accessToken Access token
+ */
+ public void setAccessToken(String accessToken) {
+ {{#hasOAuthMethods}}
+ for (Authentication auth : authentications.values()) {
+ if (auth instanceof OAuth) {
+ ((OAuth) auth).setAccessToken(accessToken);
+ return;
+ }
+ }
+ {{/hasOAuthMethods}}
+ throw new RuntimeException("No OAuth2 authentication configured!");
+ }
+
+ /**
+ * Helper method to set credentials for AWSV4 Signature
+ *
+ * @param accessKey Access Key
+ * @param secretKey Secret Key
+ * @param region Region
+ * @param service Service to access to
+ */
+ public void setAWS4Configuration(String accessKey, String secretKey, String region, String service) {
+ {{#withAWSV4Signature}}
+ for (Authentication auth : authentications.values()) {
+ if (auth instanceof AWS4Auth) {
+ ((AWS4Auth) auth).setCredentials(accessKey, secretKey);
+ ((AWS4Auth) auth).setRegion(region);
+ ((AWS4Auth) auth).setService(service);
+ return;
+ }
+ }
+ {{/withAWSV4Signature}}
+ throw new RuntimeException("No AWS4 authentication configured!");
+ }
+
+ /**
+ * Helper method to set credentials for AWSV4 Signature
+ *
+ * @param accessKey Access Key
+ * @param secretKey Secret Key
+ * @param sessionToken Session Token
+ * @param region Region
+ * @param service Service to access to
+ */
+ public void setAWS4Configuration(String accessKey, String secretKey, String sessionToken, String region, String service) {
+ {{#withAWSV4Signature}}
+ for (Authentication auth : authentications.values()) {
+ if (auth instanceof AWS4Auth) {
+ ((AWS4Auth) auth).setCredentials(accessKey, secretKey, sessionToken);
+ ((AWS4Auth) auth).setRegion(region);
+ ((AWS4Auth) auth).setService(service);
+ return;
+ }
+ }
+ {{/withAWSV4Signature}}
+ throw new RuntimeException("No AWS4 authentication configured!");
+ }
+
+ /**
+ * Set the User-Agent header's value (by adding to the default header map).
+ *
+ * @param userAgent HTTP request's user agent
+ * @return ApiClient
+ */
+ public ApiClient setUserAgent(String userAgent) {
+ addDefaultHeader("User-Agent", userAgent);
+ return this;
+ }
+
+ /**
+ * Add a default header.
+ *
+ * @param key The header's key
+ * @param value The header's value
+ * @return ApiClient
+ */
+ public ApiClient addDefaultHeader(String key, String value) {
+ defaultHeaderMap.put(key, value);
+ return this;
+ }
+
+ /**
+ * Add a default cookie.
+ *
+ * @param key The cookie's key
+ * @param value The cookie's value
+ * @return ApiClient
+ */
+ public ApiClient addDefaultCookie(String key, String value) {
+ defaultCookieMap.put(key, value);
+ return this;
+ }
+
+ /**
+ * Check that whether debugging is enabled for this API client.
+ *
+ * @return True if debugging is enabled, false otherwise.
+ */
+ public boolean isDebugging() {
+ return debugging;
+ }
+
+ /**
+ * Enable/disable debugging for this API client.
+ *
+ * @param debugging To enable (true) or disable (false) debugging
+ * @return ApiClient
+ */
+ public ApiClient setDebugging(boolean debugging) {
+ if (debugging != this.debugging) {
+ if (debugging) {
+ loggingInterceptor = new HttpLoggingInterceptor();
+ loggingInterceptor.setLevel(Level.BODY);
+ httpClient = httpClient.newBuilder().addInterceptor(loggingInterceptor).build();
+ } else {
+ final OkHttpClient.Builder builder = httpClient.newBuilder();
+ builder.interceptors().remove(loggingInterceptor);
+ httpClient = builder.build();
+ loggingInterceptor = null;
+ }
+ }
+ this.debugging = debugging;
+ return this;
+ }
+
+ /**
+ * The path of temporary folder used to store downloaded files from endpoints
+ * with file response. The default value is null, i.e. using
+ * the system's default temporary folder.
+ *
+ * @see createTempFile
+ * @return Temporary folder path
+ */
+ public String getTempFolderPath() {
+ return tempFolderPath;
+ }
+
+ /**
+ * Set the temporary folder path (for downloading files)
+ *
+ * @param tempFolderPath Temporary folder path
+ * @return ApiClient
+ */
+ public ApiClient setTempFolderPath(String tempFolderPath) {
+ this.tempFolderPath = tempFolderPath;
+ return this;
+ }
+
+ /**
+ * Get connection timeout (in milliseconds).
+ *
+ * @return Timeout in milliseconds
+ */
+ public int getConnectTimeout() {
+ return httpClient.connectTimeoutMillis();
+ }
+
+ /**
+ * Sets the connect timeout (in milliseconds).
+ * A value of 0 means no timeout, otherwise values must be between 1 and
+ * {@link java.lang.Integer#MAX_VALUE}.
+ *
+ * @param connectionTimeout connection timeout in milliseconds
+ * @return Api client
+ */
+ public ApiClient setConnectTimeout(int connectionTimeout) {
+ httpClient = httpClient.newBuilder().connectTimeout(connectionTimeout, TimeUnit.MILLISECONDS).build();
+ return this;
+ }
+
+ /**
+ * Get read timeout (in milliseconds).
+ *
+ * @return Timeout in milliseconds
+ */
+ public int getReadTimeout() {
+ return httpClient.readTimeoutMillis();
+ }
+
+ /**
+ * Sets the read timeout (in milliseconds).
+ * A value of 0 means no timeout, otherwise values must be between 1 and
+ * {@link java.lang.Integer#MAX_VALUE}.
+ *
+ * @param readTimeout read timeout in milliseconds
+ * @return Api client
+ */
+ public ApiClient setReadTimeout(int readTimeout) {
+ httpClient = httpClient.newBuilder().readTimeout(readTimeout, TimeUnit.MILLISECONDS).build();
+ return this;
+ }
+
+ /**
+ * Get write timeout (in milliseconds).
+ *
+ * @return Timeout in milliseconds
+ */
+ public int getWriteTimeout() {
+ return httpClient.writeTimeoutMillis();
+ }
+
+ /**
+ * Sets the write timeout (in milliseconds).
+ * A value of 0 means no timeout, otherwise values must be between 1 and
+ * {@link java.lang.Integer#MAX_VALUE}.
+ *
+ * @param writeTimeout connection timeout in milliseconds
+ * @return Api client
+ */
+ public ApiClient setWriteTimeout(int writeTimeout) {
+ httpClient = httpClient.newBuilder().writeTimeout(writeTimeout, TimeUnit.MILLISECONDS).build();
+ return this;
+ }
+
+ {{#hasOAuthMethods}}
+ /**
+ * Helper method to configure the token endpoint of the first oauth found in the apiAuthorizations (there should be only one)
+ *
+ * @return Token request builder
+ */
+ public TokenRequestBuilder getTokenEndPoint() {
+ for (Authentication apiAuth : authentications.values()) {
+ if (apiAuth instanceof RetryingOAuth) {
+ RetryingOAuth retryingOAuth = (RetryingOAuth) apiAuth;
+ return retryingOAuth.getTokenRequestBuilder();
+ }
+ }
+ return null;
+ }
+ {{/hasOAuthMethods}}
+
+ /**
+ * Format the given parameter object into string.
+ *
+ * @param param Parameter
+ * @return String representation of the parameter
+ */
+ public String parameterToString(Object param) {
+ if (param == null) {
+ return "";
+ } else if (param instanceof Date {{#joda}}|| param instanceof DateTime || param instanceof LocalDate{{/joda}}{{#jsr310}}|| param instanceof OffsetDateTime || param instanceof LocalDate{{/jsr310}}) {
+ //Serialize to json string and remove the " enclosing characters
+ String jsonStr = json.serialize(param);
+ return jsonStr.substring(1, jsonStr.length() - 1);
+ } else if (param instanceof Collection) {
+ StringBuilder b = new StringBuilder();
+ for (Object o : (Collection) param) {
+ if (b.length() > 0) {
+ b.append(",");
+ }
+ b.append(o);
+ }
+ return b.toString();
+ } else {
+ return String.valueOf(param);
+ }
+ }
+
+ /**
+ * Formats the specified query parameter to a list containing a single {@code Pair} object.
+ *
+ * Note that {@code value} must not be a collection.
+ *
+ * @param name The name of the parameter.
+ * @param value The value of the parameter.
+ * @return A list containing a single {@code Pair} object.
+ */
+ public List parameterToPair(String name, Object value) {
+ List params = new ArrayList();
+
+ // preconditions
+ if (name == null || name.isEmpty() || value == null || value instanceof Collection) {
+ return params;
+ }
+
+ params.add(new Pair(name, parameterToString(value)));
+ return params;
+ }
+
+ {{^dynamicOperations}}
+ /**
+ * Formats the specified collection query parameters to a list of {@code Pair} objects.
+ *
+ * Note that the values of each of the returned Pair objects are percent-encoded.
+ *
+ * @param collectionFormat The collection format of the parameter.
+ * @param name The name of the parameter.
+ * @param value The value of the parameter.
+ * @return A list of {@code Pair} objects.
+ */
+ public List parameterToPairs(String collectionFormat, String name, Collection value) {
+ List params = new ArrayList();
+
+ // preconditions
+ if (name == null || name.isEmpty() || value == null || value.isEmpty()) {
+ return params;
+ }
+
+ // create the params based on the collection format
+ if ("multi".equals(collectionFormat)) {
+ for (Object item : value) {
+ params.add(new Pair(name, escapeString(parameterToString(item))));
+ }
+ return params;
+ }
+
+ // collectionFormat is assumed to be "csv" by default
+ String delimiter = ",";
+
+ // escape all delimiters except commas, which are URI reserved
+ // characters
+ if ("ssv".equals(collectionFormat)) {
+ delimiter = escapeString(" ");
+ } else if ("tsv".equals(collectionFormat)) {
+ delimiter = escapeString("\t");
+ } else if ("pipes".equals(collectionFormat)) {
+ delimiter = escapeString("|");
+ }
+
+ StringBuilder sb = new StringBuilder();
+ for (Object item : value) {
+ sb.append(delimiter);
+ sb.append(escapeString(parameterToString(item)));
+ }
+
+ params.add(new Pair(name, sb.substring(delimiter.length())));
+
+ return params;
+ }
+ {{/dynamicOperations}}
+ {{#dynamicOperations}}
+ public List parameterToPairs(Parameter param, Collection value) {
+ List params = new ArrayList();
+
+ // preconditions
+ if (param == null || param.getName() == null || param.getName().isEmpty() || value == null || value.isEmpty()) {
+ return params;
+ }
+
+ // create the params based on the collection format
+ if (StyleEnum.FORM.equals(param.getStyle()) && Boolean.TRUE.equals(param.getExplode())) {
+ for (Object item : value) {
+ params.add(new Pair(param.getName(), escapeString(parameterToString(item))));
+ }
+ return params;
+ }
+
+ // collectionFormat is assumed to be "csv" by default
+ String delimiter = ",";
+
+ // escape all delimiters except commas, which are URI reserved
+ // characters
+ if (StyleEnum.SPACEDELIMITED.equals(param.getStyle())) {
+ delimiter = escapeString(" ");
+ } else if (StyleEnum.PIPEDELIMITED.equals(param.getStyle())) {
+ delimiter = escapeString("|");
+ }
+
+ StringBuilder sb = new StringBuilder();
+ for (Object item : value) {
+ sb.append(delimiter);
+ sb.append(escapeString(parameterToString(item)));
+ }
+
+ params.add(new Pair(param.getName(), sb.substring(delimiter.length())));
+
+ return params;
+ }
+ {{/dynamicOperations}}
+
+ /**
+ * Formats the specified free-form query parameters to a list of {@code Pair} objects.
+ *
+ * @param value The free-form query parameters.
+ * @return A list of {@code Pair} objects.
+ */
+ public List freeFormParameterToPairs(Object value) {
+ List params = new ArrayList<>();
+
+ // preconditions
+ if (value == null || !(value instanceof Map )) {
+ return params;
+ }
+
+ @SuppressWarnings("unchecked")
+ final Map valuesMap = (Map) value;
+
+ for (Map.Entry entry : valuesMap.entrySet()) {
+ params.add(new Pair(entry.getKey(), parameterToString(entry.getValue())));
+ }
+
+ return params;
+ }
+
+
+ /**
+ * Formats the specified collection path parameter to a string value.
+ *
+ * @param collectionFormat The collection format of the parameter.
+ * @param value The value of the parameter.
+ * @return String representation of the parameter
+ */
+ public String collectionPathParameterToString(String collectionFormat, Collection value) {
+ // create the value based on the collection format
+ if ("multi".equals(collectionFormat)) {
+ // not valid for path params
+ return parameterToString(value);
+ }
+
+ // collectionFormat is assumed to be "csv" by default
+ String delimiter = ",";
+
+ if ("ssv".equals(collectionFormat)) {
+ delimiter = " ";
+ } else if ("tsv".equals(collectionFormat)) {
+ delimiter = "\t";
+ } else if ("pipes".equals(collectionFormat)) {
+ delimiter = "|";
+ }
+
+ StringBuilder sb = new StringBuilder() ;
+ for (Object item : value) {
+ sb.append(delimiter);
+ sb.append(parameterToString(item));
+ }
+
+ return sb.substring(delimiter.length());
+ }
+
+ /**
+ * Sanitize filename by removing path.
+ * e.g. ../../sun.gif becomes sun.gif
+ *
+ * @param filename The filename to be sanitized
+ * @return The sanitized filename
+ */
+ public String sanitizeFilename(String filename) {
+ return filename.replaceFirst("^.*[/\\\\]", "");
+ }
+
+ /**
+ * Check if the given MIME is a JSON MIME.
+ * JSON MIME examples:
+ * application/json
+ * application/json; charset=UTF8
+ * APPLICATION/JSON
+ * application/vnd.company+json
+ * "* / *" is also default to JSON
+ * @param mime MIME (Multipurpose Internet Mail Extensions)
+ * @return True if the given MIME is JSON, false otherwise.
+ */
+ public boolean isJsonMime(String mime) {
+ String jsonMime = "(?i)^(application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(;.*)?$";
+ return mime != null && (mime.matches(jsonMime) || mime.equals("*/*"));
+ }
+
+ /**
+ * 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).
+ */
+ public 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,
+ * returns null. If it matches "any", JSON will be used.
+ */
+ public String selectHeaderContentType(String[] contentTypes) {
+ if (contentTypes.length == 0) {
+ return null;
+ }
+
+ if (contentTypes[0].equals("*/*")) {
+ return "application/json";
+ }
+
+ for (String contentType : contentTypes) {
+ if (isJsonMime(contentType)) {
+ return contentType;
+ }
+ }
+
+ return contentTypes[0];
+ }
+
+ /**
+ * Escape the given string to be used as URL query value.
+ *
+ * @param str String to be escaped
+ * @return Escaped string
+ */
+ public String escapeString(String str) {
+ try {
+ return URLEncoder.encode(str, "utf8").replaceAll("\\+", "%20");
+ } catch (UnsupportedEncodingException e) {
+ return str;
+ }
+ }
+
+ /**
+ * Deserialize response body to Java object, according to the return type and
+ * the Content-Type response header.
+ *
+ * @param Type
+ * @param response HTTP response
+ * @param returnType The type of the Java object
+ * @return The deserialized Java object
+ * @throws {{invokerPackage}}.ApiException If fail to deserialize response body, i.e. cannot read response body
+ * or the Content-Type of the response is not supported.
+ */
+ @SuppressWarnings("unchecked")
+ public T deserialize(Response response, Type returnType) throws ApiException {
+ if (response == null || returnType == null) {
+ return null;
+ }
+
+ if ("byte[]".equals(returnType.toString())) {
+ // Handle binary response (byte array).
+ try {
+ return (T) response.body().bytes();
+ } catch (IOException e) {
+ throw new ApiException(e);
+ }
+ } else if (returnType.equals(File.class)) {
+ // Handle file downloading.
+ return (T) downloadFileFromResponse(response);
+ }
+
+ ResponseBody respBody = response.body();
+ if (respBody == null) {
+ return null;
+ }
+
+ String contentType = response.headers().get("Content-Type");
+ if (contentType == null) {
+ // ensuring a default content type
+ contentType = "application/json";
+ }
+ try {
+ if (isJsonMime(contentType)) {
+ if (returnType.equals(String.class)) {
+ String respBodyString = respBody.string();
+ if (respBodyString.isEmpty()) {
+ return null;
+ }
+ // Use String-based deserialize for String return type with fallback
+ return json.deserialize(respBodyString, returnType);
+ } else {
+ // Use InputStream-based deserialize which supports responses > 2GB
+ return json.deserialize(respBody.byteStream(), returnType);
+ }
+ } else if (returnType.equals(String.class)) {
+ String respBodyString = respBody.string();
+ if (respBodyString.isEmpty()) {
+ return null;
+ }
+ // Expecting string, return the raw response body.
+ return (T) respBodyString;
+ } else {
+ throw new ApiException(
+ "Content type \"" + contentType + "\" is not supported for type: " + returnType,
+ response.code(),
+ response.headers().toMultimap(),
+ response.body().string());
+ }
+ } catch (IOException e) {
+ throw new ApiException(e);
+ }
+ }
+
+ /**
+ * Serialize the given Java object into request body according to the object's
+ * class and the request Content-Type.
+ *
+ * @param obj The Java object
+ * @param contentType The request Content-Type
+ * @return The serialized request body
+ * @throws {{invokerPackage}}.ApiException If fail to serialize the given object
+ */
+ public RequestBody serialize(Object obj, String contentType) throws ApiException {
+ if (obj instanceof byte[]) {
+ // Binary (byte array) body parameter support.
+ return RequestBody.create((byte[]) obj, MediaType.parse(contentType));
+ } else if (obj instanceof File) {
+ // File body parameter support.
+ return RequestBody.create((File) obj, MediaType.parse(contentType));
+ } else if ("text/plain".equals(contentType) && obj instanceof String) {
+ return RequestBody.create((String) obj, MediaType.parse(contentType));
+ } else if (isJsonMime(contentType)) {
+ String content;
+ if (obj != null) {
+ content = json.serialize(obj);
+ } else {
+ content = null;
+ }
+ return RequestBody.create(content, MediaType.parse(contentType));
+ } else if (obj instanceof String) {
+ return RequestBody.create((String) obj, MediaType.parse(contentType));
+ } else {
+ throw new ApiException("Content type \"" + contentType + "\" is not supported");
+ }
+ }
+
+ /**
+ * Download file from the given response.
+ *
+ * @param response An instance of the Response object
+ * @throws {{invokerPackage}}.ApiException If fail to read file content from response and write to disk
+ * @return Downloaded file
+ */
+ public File downloadFileFromResponse(Response response) throws ApiException {
+ try {
+ File file = prepareDownloadFile(response);
+ BufferedSink sink = Okio.buffer(Okio.sink(file));
+ sink.writeAll(response.body().source());
+ sink.close();
+ return file;
+ } catch (IOException e) {
+ throw new ApiException(e);
+ }
+ }
+
+ /**
+ * Prepare file for download
+ *
+ * @param response An instance of the Response object
+ * @return Prepared file for the download
+ * @throws java.io.IOException If fail to prepare file for download
+ */
+ public File prepareDownloadFile(Response response) throws IOException {
+ String filename = null;
+ String contentDisposition = response.header("Content-Disposition");
+ if (contentDisposition != null && !"".equals(contentDisposition)) {
+ // Get filename from the Content-Disposition header.
+ Pattern pattern = Pattern.compile("filename=['\"]?([^'\"\\s]+)['\"]?");
+ Matcher matcher = pattern.matcher(contentDisposition);
+ if (matcher.find()) {
+ filename = sanitizeFilename(matcher.group(1));
+ }
+ }
+
+ String prefix = null;
+ String suffix = null;
+ if (filename == null) {
+ prefix = "download-";
+ suffix = "";
+ } else {
+ int pos = filename.lastIndexOf(".");
+ if (pos == -1) {
+ prefix = filename + "-";
+ } else {
+ prefix = filename.substring(0, pos) + "-";
+ suffix = filename.substring(pos);
+ }
+ // Files.createTempFile requires the prefix to be at least three characters long
+ if (prefix.length() < 3)
+ prefix = "download-";
+ }
+
+ if (tempFolderPath == null)
+ return Files.createTempFile(prefix, suffix).toFile();
+ else
+ return Files.createTempFile(Paths.get(tempFolderPath), prefix, suffix).toFile();
+ }
+
+ /**
+ * {@link #execute(Call, Type)}
+ *
+ * @param Type
+ * @param call An instance of the Call object
+ * @return ApiResponse<T>
+ * @throws {{invokerPackage}}.ApiException If fail to execute the call
+ */
+ public ApiResponse execute(Call call) throws ApiException {
+ return execute(call, null);
+ }
+
+ /**
+ * Execute HTTP call and deserialize the HTTP response body into the given return type.
+ *
+ * @param returnType The return type used to deserialize HTTP response body
+ * @param The return type corresponding to (same with) returnType
+ * @param call Call
+ * @return ApiResponse object containing response status, headers and
+ * data, which is a Java object deserialized from response body and would be null
+ * when returnType is null.
+ * @throws {{invokerPackage}}.ApiException If fail to execute the call
+ */
+ public ApiResponse execute(Call call, Type returnType) throws ApiException {
+ try {
+ Response response = call.execute();
+ T data = handleResponse(response, returnType);
+ return new ApiResponse(response.code(), response.headers().toMultimap(), data);
+ } catch (IOException e) {
+ throw new ApiException(e);
+ }
+ }
+
+ {{#supportStreaming}}
+ /**
+ * Execute stream.
+ *
+ * @param call a {@link okhttp3.Call} object
+ * @param returnType a {@link java.lang.reflect.Type} object
+ * @return a {@link java.io.InputStream} object
+ * @throws {{invokerPackage}}.ApiException if any.
+ */
+ public InputStream executeStream(Call call, Type returnType) throws ApiException {
+ try {
+ Response response = call.execute();
+ if (!response.isSuccessful()) {
+ throw new ApiException(response.code(), response.message(), response.headers().toMultimap(), null);
+ }
+ if (response.body() == null) {
+ return null;
+ }
+ return response.body().byteStream();
+ } catch (IOException e) {
+ throw new ApiException(e);
+ }
+ }
+
+ {{/supportStreaming}}
+ /**
+ * {@link #executeAsync(Call, Type, ApiCallback)}
+ *
+ * @param Type
+ * @param call An instance of the Call object
+ * @param callback ApiCallback<T>
+ */
+ public void executeAsync(Call call, ApiCallback callback) {
+ executeAsync(call, null, callback);
+ }
+
+ /**
+ * Execute HTTP call asynchronously.
+ *
+ * @param Type
+ * @param call The callback to be executed when the API call finishes
+ * @param returnType Return type
+ * @param callback ApiCallback
+ * @see #execute(Call, Type)
+ */
+ @SuppressWarnings("unchecked")
+ public void executeAsync(Call call, final Type returnType, final ApiCallback callback) {
+ call.enqueue(new Callback() {
+ @Override
+ public void onFailure(Call call, IOException e) {
+ callback.onFailure(new ApiException(e), 0, null);
+ }
+
+ @Override
+ public void onResponse(Call call, Response response) throws IOException {
+ T result;
+ try {
+ result = (T) handleResponse(response, returnType);
+ } catch (ApiException e) {
+ callback.onFailure(e, response.code(), response.headers().toMultimap());
+ return;
+ } catch (Exception e) {
+ callback.onFailure(new ApiException(e), response.code(), response.headers().toMultimap());
+ return;
+ }
+ callback.onSuccess(result, response.code(), response.headers().toMultimap());
+ }
+ });
+ }
+
+ /**
+ * Handle the given response, return the deserialized object when the response is successful.
+ *
+ * @param Type
+ * @param response Response
+ * @param returnType Return type
+ * @return Type
+ * @throws {{invokerPackage}}.ApiException If the response has an unsuccessful status code or
+ * fail to deserialize the response body
+ */
+ public T handleResponse(Response response, Type returnType) throws ApiException {
+ if (response.isSuccessful()) {
+ if (returnType == null || response.code() == 204) {
+ // returning null if the returnType is not defined,
+ // or the status code is 204 (No Content)
+ if (response.body() != null) {
+ try {
+ response.body().close();
+ } catch (Exception e) {
+ throw new ApiException(response.message(), e, response.code(), response.headers().toMultimap());
+ }
+ }
+ return null;
+ } else {
+ return deserialize(response, returnType);
+ }
+ } else {
+ String respBody = null;
+ if (response.body() != null) {
+ try {
+ respBody = response.body().string();
+ } catch (IOException e) {
+ throw new ApiException(response.message(), e, response.code(), response.headers().toMultimap());
+ }
+ }
+ throw new ApiException(response.message(), response.code(), response.headers().toMultimap(), respBody);
+ }
+ }
+
+ /**
+ * Build HTTP call with the given options.
+ *
+ * @param baseUrl The base URL
+ * @param path The sub-path of the HTTP URL
+ * @param method The request method, one of "GET", "HEAD", "OPTIONS", "POST", "PUT", "PATCH" and "DELETE"
+ * @param queryParams The query parameters
+ * @param collectionQueryParams The collection query parameters
+ * @param body The request body object
+ * @param headerParams The header parameters
+ * @param cookieParams The cookie parameters
+ * @param formParams The form parameters
+ * @param authNames The authentications to apply
+ * @param callback Callback for upload/download progress
+ * @return The HTTP call
+ * @throws {{invokerPackage}}.ApiException If fail to serialize the request body object
+ */
+ public Call buildCall(String baseUrl, String path, String method, List queryParams, List collectionQueryParams, Object body, Map headerParams, Map cookieParams, Map formParams, String[] authNames, ApiCallback callback) throws ApiException {
+ Request request = buildRequest(baseUrl, path, method, queryParams, collectionQueryParams, body, headerParams, cookieParams, formParams, authNames, callback);
+
+ return httpClient.newCall(request);
+ }
+
+ /**
+ * Build an HTTP request with the given options.
+ *
+ * @param baseUrl The base URL
+ * @param path The sub-path of the HTTP URL
+ * @param method The request method, one of "GET", "HEAD", "OPTIONS", "POST", "PUT", "PATCH" and "DELETE"
+ * @param queryParams The query parameters
+ * @param collectionQueryParams The collection query parameters
+ * @param body The request body object
+ * @param headerParams The header parameters
+ * @param cookieParams The cookie parameters
+ * @param formParams The form parameters
+ * @param authNames The authentications to apply
+ * @param callback Callback for upload/download progress
+ * @return The HTTP request
+ * @throws {{invokerPackage}}.ApiException If fail to serialize the request body object
+ */
+ public Request buildRequest(String baseUrl, String path, String method, List queryParams, List collectionQueryParams, Object body, Map headerParams, Map cookieParams, Map formParams, String[] authNames, ApiCallback callback) throws ApiException {
+ final String url = buildUrl(baseUrl, path, queryParams, collectionQueryParams);
+
+ // prepare HTTP request body
+ RequestBody reqBody;
+ String contentType = headerParams.get("Content-Type");
+ String contentTypePure = contentType;
+ if (contentTypePure != null && contentTypePure.contains(";")) {
+ contentTypePure = contentType.substring(0, contentType.indexOf(";"));
+ }
+ if (!HttpMethod.permitsRequestBody(method)) {
+ reqBody = null;
+ } else if ("application/x-www-form-urlencoded".equals(contentTypePure)) {
+ reqBody = buildRequestBodyFormEncoding(formParams);
+ } else if ("multipart/form-data".equals(contentTypePure)) {
+ reqBody = buildRequestBodyMultipart(formParams);
+ } else if (body == null) {
+ if ("DELETE".equals(method)) {
+ // allow calling DELETE without sending a request body
+ reqBody = null;
+ } else {
+ // use an empty request body (for POST, PUT and PATCH)
+ reqBody = RequestBody.create("", contentType == null ? null : MediaType.parse(contentType));
+ }
+ } else {
+ reqBody = serialize(body, contentType);
+ }
+
+ List updatedQueryParams = new ArrayList<>(queryParams);
+
+ byte[] localVarPayload = requestBodyToBytes(reqBody);
+
+ // update parameters with authentication settings
+ for (String authName : authNames) {
+ Authentication auth = authentications.get(authName);
+ if (auth == null) {
+ throw new RuntimeException("Authentication undefined: " + authName);
+ }
+ {{#withAWSV4Signature}}
+ if (!(auth instanceof AWS4Auth)) {
+ URI currentUri = URI.create(buildUrl(baseUrl, path, updatedQueryParams, collectionQueryParams));
+ auth.applyToParams(updatedQueryParams, headerParams, cookieParams, localVarPayload, method, currentUri);
+ }
+ {{/withAWSV4Signature}}
+ {{^withAWSV4Signature}}
+ URI currentUri = URI.create(buildUrl(baseUrl, path, updatedQueryParams, collectionQueryParams));
+ auth.applyToParams(updatedQueryParams, headerParams, cookieParams, localVarPayload, method, currentUri);
+ {{/withAWSV4Signature}}
+ }
+ {{#withAWSV4Signature}}
+ for (String authName : authNames) {
+ Authentication auth = authentications.get(authName);
+ if (auth instanceof AWS4Auth) {
+ URI currentUri = URI.create(buildUrl(baseUrl, path, updatedQueryParams, collectionQueryParams));
+ auth.applyToParams(updatedQueryParams, headerParams, cookieParams, localVarPayload, method, currentUri);
+ }
+ }
+ {{/withAWSV4Signature}}
+
+ final Request.Builder reqBuilder = new Request.Builder().url(buildUrl(baseUrl, path, updatedQueryParams, collectionQueryParams));
+ processHeaderParams(headerParams, reqBuilder);
+ processCookieParams(cookieParams, reqBuilder);
+
+ // Associate callback with request (if not null) so interceptor can
+ // access it when creating ProgressResponseBody
+ reqBuilder.tag(callback);
+
+ Request request = null;
+
+ if (callback != null && reqBody != null) {
+ ProgressRequestBody progressRequestBody = new ProgressRequestBody(reqBody, callback);
+ request = reqBuilder.method(method, progressRequestBody).build();
+ } else {
+ request = reqBuilder.method(method, reqBody).build();
+ }
+
+ return request;
+ }
+
+ /**
+ * Build full URL by concatenating base path, the given sub path and query parameters.
+ *
+ * @param baseUrl The base URL
+ * @param path The sub path
+ * @param queryParams The query parameters
+ * @param collectionQueryParams The collection query parameters
+ * @return The full URL
+ */
+ public String buildUrl(String baseUrl, String path, List queryParams, List collectionQueryParams) {
+ final StringBuilder url = new StringBuilder();
+ if (baseUrl != null) {
+ url.append(baseUrl).append(path);
+ } else {
+ String baseURL;
+ if (serverIndex != null) {
+ if (serverIndex < 0 || serverIndex >= servers.size()) {
+ throw new ArrayIndexOutOfBoundsException(String.format(
+ java.util.Locale.ROOT,
+ "Invalid index %d when selecting the host settings. Must be less than %d", serverIndex, servers.size()
+ ));
+ }
+ baseURL = servers.get(serverIndex).URL(serverVariables);
+ } else {
+ baseURL = basePath;
+ }
+ url.append(baseURL).append(path);
+ }
+
+ if (queryParams != null && !queryParams.isEmpty()) {
+ // support (constant) query string in `path`, e.g. "/posts?draft=1"
+ String prefix = path.contains("?") ? "&" : "?";
+ for (Pair param : queryParams) {
+ if (param.getValue() != null) {
+ if (prefix != null) {
+ url.append(prefix);
+ prefix = null;
+ } else {
+ url.append("&");
+ }
+ String value = parameterToString(param.getValue());
+ url.append(escapeString(param.getName())).append("=").append(escapeString(value));
+ }
+ }
+ }
+
+ if (collectionQueryParams != null && !collectionQueryParams.isEmpty()) {
+ String prefix = url.toString().contains("?") ? "&" : "?";
+ for (Pair param : collectionQueryParams) {
+ if (param.getValue() != null) {
+ if (prefix != null) {
+ url.append(prefix);
+ prefix = null;
+ } else {
+ url.append("&");
+ }
+ String value = parameterToString(param.getValue());
+ // collection query parameter value already escaped as part of parameterToPairs
+ url.append(escapeString(param.getName())).append("=").append(value);
+ }
+ }
+ }
+
+ return url.toString();
+ }
+
+ /**
+ * Set header parameters to the request builder, including default headers.
+ *
+ * @param headerParams Header parameters in the form of Map
+ * @param reqBuilder Request.Builder
+ */
+ public void processHeaderParams(Map headerParams, Request.Builder reqBuilder) {
+ for (Entry param : headerParams.entrySet()) {
+ reqBuilder.header(param.getKey(), parameterToString(param.getValue()));
+ }
+ for (Entry header : defaultHeaderMap.entrySet()) {
+ if (!headerParams.containsKey(header.getKey())) {
+ reqBuilder.header(header.getKey(), parameterToString(header.getValue()));
+ }
+ }
+ }
+
+ /**
+ * Set cookie parameters to the request builder, including default cookies.
+ *
+ * @param cookieParams Cookie parameters in the form of Map
+ * @param reqBuilder Request.Builder
+ */
+ public void processCookieParams(Map cookieParams, Request.Builder reqBuilder) {
+ for (Entry param : cookieParams.entrySet()) {
+ reqBuilder.addHeader("Cookie", String.format(java.util.Locale.ROOT, "%s=%s", param.getKey(), param.getValue()));
+ }
+ for (Entry param : defaultCookieMap.entrySet()) {
+ if (!cookieParams.containsKey(param.getKey())) {
+ reqBuilder.addHeader("Cookie", String.format(java.util.Locale.ROOT, "%s=%s", param.getKey(), param.getValue()));
+ }
+ }
+ }
+
+ /**
+ * Update query and header parameters based on authentication settings.
+ *
+ * @param authNames The authentications to apply
+ * @param queryParams List of query parameters
+ * @param headerParams Map of header parameters
+ * @param cookieParams Map of cookie parameters
+ * @param payload HTTP request body
+ * @param method HTTP method
+ * @param uri URI
+ * @throws {{invokerPackage}}.ApiException If fails to update the parameters
+ */
+ public void updateParamsForAuth(String[] authNames, List queryParams, Map headerParams,
+ Map cookieParams, byte[] payload, String method, URI uri) throws ApiException {
+ for (String authName : authNames) {
+ Authentication auth = authentications.get(authName);
+ if (auth == null) {
+ throw new RuntimeException("Authentication undefined: " + authName);
+ }
+ auth.applyToParams(queryParams, headerParams, cookieParams, payload, method, uri);
+ }
+ }
+
+ /**
+ * Build a form-encoding request body with the given form parameters.
+ *
+ * @param formParams Form parameters in the form of Map
+ * @return RequestBody
+ */
+ public RequestBody buildRequestBodyFormEncoding(Map formParams) {
+ okhttp3.FormBody.Builder formBuilder = new okhttp3.FormBody.Builder();
+ for (Entry param : formParams.entrySet()) {
+ formBuilder.add(param.getKey(), parameterToString(param.getValue()));
+ }
+ return formBuilder.build();
+ }
+
+ /**
+ * Build a multipart (file uploading) request body with the given form parameters,
+ * which could contain text fields and file fields.
+ *
+ * @param formParams Form parameters in the form of Map
+ * @return RequestBody
+ */
+ public RequestBody buildRequestBodyMultipart(Map formParams) {
+ MultipartBody.Builder mpBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
+ for (Entry param : formParams.entrySet()) {
+ if (param.getValue() instanceof File) {
+ File file = (File) param.getValue();
+ addPartToMultiPartBuilder(mpBuilder, param.getKey(), file);
+ } else if (param.getValue() instanceof List) {
+ List list = (List) param.getValue();
+ for (Object item: list) {
+ if (item instanceof File) {
+ addPartToMultiPartBuilder(mpBuilder, param.getKey(), (File) item);
+ } else {
+ addPartToMultiPartBuilder(mpBuilder, param.getKey(), param.getValue());
+ }
+ }
+ } else {
+ addPartToMultiPartBuilder(mpBuilder, param.getKey(), param.getValue());
+ }
+ }
+ return mpBuilder.build();
+ }
+
+ /**
+ * Guess Content-Type header from the given file (defaults to "application/octet-stream").
+ *
+ * @param file The given file
+ * @return The guessed Content-Type
+ */
+ public String guessContentTypeFromFile(File file) {
+ String contentType = URLConnection.guessContentTypeFromName(file.getName());
+ if (contentType == null) {
+ return "application/octet-stream";
+ } else {
+ return contentType;
+ }
+ }
+
+ /**
+ * Add a Content-Disposition Header for the given key and file to the MultipartBody Builder.
+ *
+ * @param mpBuilder MultipartBody.Builder
+ * @param key The key of the Header element
+ * @param file The file to add to the Header
+ */
+ protected void addPartToMultiPartBuilder(MultipartBody.Builder mpBuilder, String key, File file) {
+ Headers partHeaders = Headers.of("Content-Disposition", "form-data; name=\"" + key + "\"; filename=\"" + file.getName() + "\"");
+ MediaType mediaType = MediaType.parse(guessContentTypeFromFile(file));
+ mpBuilder.addPart(partHeaders, RequestBody.create(file, mediaType));
+ }
+
+ /**
+ * Add a Content-Disposition Header for the given key and complex object to the MultipartBody Builder.
+ *
+ * @param mpBuilder MultipartBody.Builder
+ * @param key The key of the Header element
+ * @param obj The complex object to add to the Header
+ */
+ protected void addPartToMultiPartBuilder(MultipartBody.Builder mpBuilder, String key, Object obj) {
+ RequestBody requestBody;
+ if (obj instanceof String) {
+ requestBody = RequestBody.create((String) obj, MediaType.parse("text/plain"));
+ } else {
+ String content;
+ if (obj != null) {
+ content = json.serialize(obj);
+ } else {
+ content = null;
+ }
+ requestBody = RequestBody.create(content, MediaType.parse("application/json"));
+ }
+
+ Headers partHeaders = Headers.of("Content-Disposition", "form-data; name=\"" + key + "\"");
+ mpBuilder.addPart(partHeaders, requestBody);
+ }
+
+ /**
+ * Get network interceptor to add it to the httpClient to track download progress for
+ * async requests.
+ */
+ protected Interceptor getProgressInterceptor() {
+ return new Interceptor() {
+ @Override
+ public Response intercept(Interceptor.Chain chain) throws IOException {
+ final Request request = chain.request();
+ final Response originalResponse = chain.proceed(request);
+ if (request.tag() instanceof ApiCallback) {
+ final ApiCallback callback = (ApiCallback) request.tag();
+ return originalResponse.newBuilder()
+ .body(new ProgressResponseBody(originalResponse.body(), callback))
+ .build();
+ }
+ return originalResponse;
+ }
+ };
+ }
+
+ /**
+ * Apply SSL related settings to httpClient according to the current values of
+ * verifyingSsl and sslCaCert.
+ */
+ protected void applySslSettings() {
+ try {
+ TrustManager[] trustManagers;
+ HostnameVerifier hostnameVerifier;
+ if (!verifyingSsl) {
+ trustManagers = new TrustManager[]{
+ new X509TrustManager() {
+ @Override
+ public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+ }
+
+ @Override
+ public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
+ }
+
+ @Override
+ public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+ return new java.security.cert.X509Certificate[]{};
+ }
+ }
+ };
+ hostnameVerifier = new HostnameVerifier() {
+ @Override
+ public boolean verify(String hostname, SSLSession session) {
+ return true;
+ }
+ };
+ } else {
+ TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+
+ if (sslCaCert == null) {
+ trustManagerFactory.init((KeyStore) null);
+ } else {
+ char[] password = null; // Any password will work.
+ CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
+ Collection certificates = certificateFactory.generateCertificates(sslCaCert);
+ if (certificates.isEmpty()) {
+ throw new IllegalArgumentException("expected non-empty set of trusted certificates");
+ }
+ KeyStore caKeyStore = newEmptyKeyStore(password);
+ int index = 0;
+ for (Certificate certificate : certificates) {
+ String certificateAlias = "ca" + (index++);
+ caKeyStore.setCertificateEntry(certificateAlias, certificate);
+ }
+ trustManagerFactory.init(caKeyStore);
+ }
+ trustManagers = trustManagerFactory.getTrustManagers();
+ if (tlsServerName != null && !tlsServerName.isEmpty()) {
+ hostnameVerifier = new HostnameVerifier() {
+ @Override
+ public boolean verify(String hostname, SSLSession session) {
+ // Verify the certificate against tlsServerName instead of the actual hostname
+ return OkHostnameVerifier.INSTANCE.verify(tlsServerName, session);
+ }
+ };
+ } else {
+ hostnameVerifier = OkHostnameVerifier.INSTANCE;
+ }
+ }
+
+ SSLContext sslContext = SSLContext.getInstance("TLS");
+ sslContext.init(keyManagers, trustManagers, new SecureRandom());
+ httpClient = httpClient.newBuilder()
+ .sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustManagers[0])
+ .hostnameVerifier(hostnameVerifier)
+ .build();
+ } catch (GeneralSecurityException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ protected KeyStore newEmptyKeyStore(char[] password) throws GeneralSecurityException {
+ try {
+ KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+ keyStore.load(null, password);
+ return keyStore;
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+ }
+ {{#dynamicOperations}}
+
+ public ApiClient createOperationLookupMap(OpenAPI openAPI) {
+ operationLookupMap = new HashMap<>();
+ for (Map.Entry pathItemEntry : openAPI.getPaths().entrySet()) {
+ String path = pathItemEntry.getKey();
+ PathItem pathItem = pathItemEntry.getValue();
+ addOperationLookupEntry(path, "GET", pathItem.getGet());
+ addOperationLookupEntry(path, "PUT", pathItem.getPut());
+ addOperationLookupEntry(path, "POST", pathItem.getPost());
+ addOperationLookupEntry(path, "DELETE", pathItem.getDelete());
+ addOperationLookupEntry(path, "OPTIONS", pathItem.getOptions());
+ addOperationLookupEntry(path, "HEAD", pathItem.getHead());
+ addOperationLookupEntry(path, "PATCH", pathItem.getPatch());
+ addOperationLookupEntry(path, "TRACE", pathItem.getTrace());
+ }
+ return this;
+ }
+
+ protected void addOperationLookupEntry(String path, String method, Operation operation) {
+ if ( operation != null && operation.getOperationId() != null) {
+ operationLookupMap.put(
+ operation.getOperationId(),
+ new ApiOperation(path, method, operation));
+ }
+ }
+
+ public Map getOperationLookupMap() {
+ return operationLookupMap;
+ }
+
+ public String fillParametersFromOperation(
+ Operation operation,
+ Map paramMap,
+ String path,
+ List queryParams,
+ List collectionQueryParams,
+ Map headerParams,
+ Map cookieParams
+ ) {
+ for (Map.Entry entry : paramMap.entrySet()) {
+ Object value = entry.getValue();
+ for (Parameter param : operation.getParameters()) {
+ if (entry.getKey().equals(param.getName())) {
+ switch (param.getIn()) {
+ case "path":
+ path = path.replace("{" + param.getName() + "}", escapeString(value.toString()));
+ break;
+ case "query":
+ if (value instanceof Collection) {
+ collectionQueryParams.addAll(parameterToPairs(param, (Collection) value));
+ } else {
+ queryParams.addAll(parameterToPair(param.getName(), value));
+ }
+ break;
+ case "header":
+ headerParams.put(param.getName(), parameterToString(value));
+ break;
+ case "cookie":
+ cookieParams.put(param.getName(), parameterToString(value));
+ break;
+ default:
+ throw new IllegalStateException("Unexpected param in: " + param.getIn());
+ }
+
+ }
+ }
+ }
+ return path;
+ }
+ {{/dynamicOperations}}
+
+ /**
+ * Convert the HTTP request body to a byte array.
+ *
+ * @param requestBody The HTTP request object
+ * @return The byte array representation of the HTTP request body
+ * @throws {{invokerPackage}}.ApiException If fail to serialize the request body object into a byte array
+ */
+ protected byte[] requestBodyToBytes(RequestBody requestBody) throws ApiException {
+ if (requestBody != null) {
+ try {
+ final Buffer buffer = new Buffer();
+ requestBody.writeTo(buffer);
+ return buffer.readByteArray();
+ } catch (final IOException e) {
+ throw new ApiException(e);
+ }
+ }
+
+ // empty http request body
+ return new byte[0];
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/ApiResponse.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/ApiResponse.mustache
new file mode 100644
index 000000000000..cecbaac1df27
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/ApiResponse.mustache
@@ -0,0 +1,75 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}};
+
+import java.util.List;
+import java.util.Map;
+{{#caseInsensitiveResponseHeaders}}
+import java.util.Map.Entry;
+import java.util.TreeMap;
+{{/caseInsensitiveResponseHeaders}}
+
+/**
+ * API response returned by API call.
+ */
+public class ApiResponse {
+ final private int statusCode;
+ final private Map> headers;
+ final private T data;
+
+ /**
+ * Constructor for ApiResponse.
+ *
+ * @param statusCode The status code of HTTP response
+ * @param headers The headers of HTTP response
+ */
+ public ApiResponse(int statusCode, Map> headers) {
+ this(statusCode, headers, null);
+ }
+
+ /**
+ * Constructor for ApiResponse.
+ *
+ * @param statusCode The status code of HTTP response
+ * @param headers The headers of HTTP response
+ * @param data The object deserialized from response bod
+ */
+ public ApiResponse(int statusCode, Map> headers, T data) {
+ this.statusCode = statusCode;
+ {{#caseInsensitiveResponseHeaders}}
+ Map> responseHeaders = new TreeMap>(String.CASE_INSENSITIVE_ORDER);
+ for(Entry> entry : headers.entrySet()){
+ responseHeaders.put(entry.getKey().toLowerCase(), entry.getValue());
+ }
+ {{/caseInsensitiveResponseHeaders}}
+ this.headers = {{#caseInsensitiveResponseHeaders}}responseHeaders{{/caseInsensitiveResponseHeaders}}{{^caseInsensitiveResponseHeaders}}headers{{/caseInsensitiveResponseHeaders}};
+ this.data = data;
+ }
+
+ /**
+ * Get the status code.
+ *
+ * @return the status code
+ */
+ public int getStatusCode() {
+ return statusCode;
+ }
+
+ /**
+ * Get the headers.
+ *
+ * @return a {@link java.util.Map} of headers
+ */
+ public Map> getHeaders() {
+ return headers;
+ }
+
+ /**
+ * Get the data.
+ *
+ * @return the data
+ */
+ public T getData() {
+ return data;
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/GzipRequestInterceptor.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/GzipRequestInterceptor.mustache
new file mode 100644
index 000000000000..dada1e92e4c5
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/GzipRequestInterceptor.mustache
@@ -0,0 +1,80 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}};
+
+import okhttp3.*;
+import okio.Buffer;
+import okio.BufferedSink;
+import okio.GzipSink;
+import okio.Okio;
+
+import java.io.IOException;
+
+/**
+ * Encodes request bodies using gzip.
+ *
+ * Taken from https://github.com/square/okhttp/issues/350
+ */
+class GzipRequestInterceptor implements Interceptor {
+ @Override
+ public Response intercept(Chain chain) throws IOException {
+ Request originalRequest = chain.request();
+ RequestBody body = originalRequest.body();
+ if (body == null || originalRequest.header("Content-Encoding") != null || body.contentLength() == 0) {
+ return chain.proceed(originalRequest);
+ }
+
+ Request compressedRequest = originalRequest.newBuilder()
+ .header("Content-Encoding", "gzip")
+ .method(originalRequest.method(), forceContentLength(gzip(body)))
+ .build();
+ return chain.proceed(compressedRequest);
+ }
+
+ /**
+ * The gzip body reports an unknown content length, which makes OkHttp fall back to
+ * "Transfer-Encoding: chunked". Servers that reject chunked request bodies then fail every
+ * compressed request, so buffer the compressed bytes and republish their known length.
+ */
+ private RequestBody forceContentLength(final RequestBody requestBody) throws IOException {
+ final Buffer buffer = new Buffer();
+ requestBody.writeTo(buffer);
+ return new RequestBody() {
+ @Override
+ public MediaType contentType() {
+ return requestBody.contentType();
+ }
+
+ @Override
+ public long contentLength() {
+ return buffer.size();
+ }
+
+ @Override
+ public void writeTo(BufferedSink sink) throws IOException {
+ sink.write(buffer.snapshot());
+ }
+ };
+ }
+
+ private RequestBody gzip(final RequestBody body) {
+ return new RequestBody() {
+ @Override
+ public MediaType contentType() {
+ return body.contentType();
+ }
+
+ @Override
+ public long contentLength() {
+ return -1; // We don't know the compressed length in advance!
+ }
+
+ @Override
+ public void writeTo(BufferedSink sink) throws IOException {
+ BufferedSink gzipSink = Okio.buffer(new GzipSink(sink));
+ body.writeTo(gzipSink);
+ gzipSink.close();
+ }
+ };
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/JSON.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/JSON.mustache
new file mode 100644
index 000000000000..b987900a8663
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/JSON.mustache
@@ -0,0 +1,1507 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}};
+
+import {{modelPackage}}.AbstractOpenApiSchema;
+
+{{#isGson}}
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonParseException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.internal.bind.util.ISO8601Utils;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+import com.google.gson.JsonElement;
+import io.gsonfire.GsonFireBuilder;
+import io.gsonfire.TypeSelector;
+{{/isGson}}
+{{#isJackson}}
+import {{jacksonPackage}}.core.JsonGenerator;
+import {{jacksonPackage}}.core.JsonParser;
+import {{jacksonPackage}}.core.JsonToken;
+{{#useJackson3}}
+import {{jacksonPackage}}.core.JacksonException;
+import {{jacksonPackage}}.core.json.JsonReadFeature;
+{{/useJackson3}}
+import com.fasterxml.jackson.annotation.*;
+import {{jacksonPackage}}.databind.*;
+import {{jacksonPackage}}.databind.json.JsonMapper;
+import {{jacksonPackage}}.databind.module.SimpleModule;
+{{^useJackson3}}
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+{{/useJackson3}}
+{{#useJackson3}}
+import {{jacksonPackage}}.databind.cfg.DateTimeFeature;
+import {{jacksonPackage}}.databind.cfg.EnumFeature;
+{{/useJackson3}}
+{{#openApiNullable}}
+import org.openapitools.jackson.nullable.{{#useJackson3}}JsonNullableJackson3Module{{/useJackson3}}{{^useJackson3}}JsonNullableModule{{/useJackson3}};
+{{/openApiNullable}}
+{{/isJackson}}
+{{#isJsonb}}
+import jakarta.json.bind.Jsonb;
+import jakarta.json.bind.JsonbBuilder;
+import jakarta.json.bind.JsonbConfig;
+import jakarta.json.bind.adapter.JsonbAdapter;
+{{/isJsonb}}
+
+{{#joda}}
+import org.joda.time.DateTime;
+import org.joda.time.LocalDate;
+{{#isGson}}
+import org.joda.time.format.DateTimeFormatter;
+import org.joda.time.format.DateTimeFormatterBuilder;
+import org.joda.time.format.ISODateTimeFormat;
+{{/isGson}}
+{{#isJackson}}
+import {{jacksonPackage}}.datatype.joda.JodaModule;
+{{/isJackson}}
+{{/joda}}
+
+import okio.ByteString;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.StringReader;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.ParsePosition;
+{{#jsr310}}
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+{{/jsr310}}
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.Locale;
+import java.util.Map;
+import java.util.HashMap;
+
+/*
+ * A JSON utility class
+ */
+public class JSON {
+ {{#isGson}}
+ private static Gson gson;
+ private static boolean isLenientOnJson = false;
+ private static DateTypeAdapter dateTypeAdapter = new DateTypeAdapter();
+ private static SqlDateTypeAdapter sqlDateTypeAdapter = new SqlDateTypeAdapter();
+ {{#joda}}
+ private static DateTimeTypeAdapter dateTimeTypeAdapter = new DateTimeTypeAdapter();
+ private static LocalDateTypeAdapter localDateTypeAdapter = new LocalDateTypeAdapter();
+ {{/joda}}
+ {{#jsr310}}
+ private static OffsetDateTimeTypeAdapter offsetDateTimeTypeAdapter = new OffsetDateTimeTypeAdapter();
+ private static LocalDateTypeAdapter localDateTypeAdapter = new LocalDateTypeAdapter();
+ private static LocalDateTimeTypeAdapter localDateTimeTypeAdapter = new LocalDateTimeTypeAdapter();
+ {{/jsr310}}
+ private static ByteArrayAdapter byteArrayAdapter = new ByteArrayAdapter();
+ {{/isGson}}
+ {{#isJackson}}
+ private static ObjectMapper mapper;
+ {{/isJackson}}
+ {{#isJsonb}}
+ private static Jsonb jsonb;
+ {{! A Jsonb instance is immutable, so the configured formats are kept here and the instance is
+ rebuilt from scratch whenever one of them changes. }}
+ private static DateFormat dateFormat;
+ private static DateFormat sqlDateFormat;
+ {{#jsr310}}
+ private static DateTimeFormatter offsetDateTimeFormat;
+ private static DateTimeFormatter localDateFormat;
+ private static DateTimeFormatter localDateTimeFormat;
+ {{/jsr310}}
+ {{#joda}}
+ private static DateTimeFormatter dateTimeFormat;
+ private static DateTimeFormatter jodaLocalDateFormat;
+ {{/joda}}
+ {{/isJsonb}}
+
+ public JSON() {
+ {{#isGson}}
+ GsonFireBuilder fireBuilder = new GsonFireBuilder();
+ {{#models}}
+ {{#model}}
+ {{#discriminator}}
+ fireBuilder.registerTypeSelector({{modelPackage}}.{{classname}}.class, new TypeSelector<{{modelPackage}}.{{classname}}>() {
+ @Override
+ public Class getClassForElement(JsonElement readElement) {
+ Map classByDiscriminatorValue = new HashMap();
+ {{#mappedModels}}
+ classByDiscriminatorValue.put("{{mappingName}}"{{^discriminatorCaseSensitive}}.toUpperCase(Locale.ROOT){{/discriminatorCaseSensitive}}, {{modelPackage}}.{{modelName}}.class);
+ {{/mappedModels}}
+ classByDiscriminatorValue.put("{{name}}"{{^discriminatorCaseSensitive}}.toUpperCase(Locale.ROOT){{/discriminatorCaseSensitive}}, {{modelPackage}}.{{classname}}.class);
+ return getClassByDiscriminator(classByDiscriminatorValue,
+ getDiscriminatorValue(readElement, "{{{propertyBaseName}}}"));
+ }
+ });
+ {{/discriminator}}
+ {{/model}}
+ {{/models}}
+ GsonBuilder builder = fireBuilder.createGsonBuilder();
+ {{#disableHtmlEscaping}}
+ builder.disableHtmlEscaping();
+ {{/disableHtmlEscaping}}
+ builder.registerTypeAdapter(Date.class, dateTypeAdapter);
+ builder.registerTypeAdapter(java.sql.Date.class, sqlDateTypeAdapter);
+ {{#joda}}
+ builder.registerTypeAdapter(DateTime.class, dateTimeTypeAdapter);
+ builder.registerTypeAdapter(LocalDate.class, localDateTypeAdapter);
+ {{/joda}}
+ {{#jsr310}}
+ builder.registerTypeAdapter(OffsetDateTime.class, offsetDateTimeTypeAdapter);
+ builder.registerTypeAdapter(LocalDate.class, localDateTypeAdapter);
+ builder.registerTypeAdapter(LocalDateTime.class, localDateTimeTypeAdapter);
+ {{/jsr310}}
+ builder.registerTypeAdapter(byte[].class, byteArrayAdapter);
+ {{#models}}
+ {{#model}}
+ {{^isEnum}}
+ {{^hasChildren}}
+ builder.registerTypeAdapterFactory(new {{modelPackage}}.{{{classname}}}.CustomTypeAdapterFactory());
+ {{/hasChildren}}
+ {{/isEnum}}
+ {{/model}}
+ {{/models}}
+ gson = builder.create();
+ {{/isGson}}
+ {{#isJackson}}
+ if (mapper == null) {
+ {{^useJackson3}}
+ mapper = JsonMapper.builder()
+ .serializationInclusion(JsonInclude.Include.NON_NULL)
+ .disable(MapperFeature.ALLOW_COERCION_OF_SCALARS)
+ {{#failOnUnknownProperties}}
+ .enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+ {{/failOnUnknownProperties}}
+ {{^failOnUnknownProperties}}
+ .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+ {{/failOnUnknownProperties}}
+ .enable(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE)
+ .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+ .enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING)
+ .enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING)
+ .defaultDateFormat(new RFC3339DateFormat())
+ .addModule(new JavaTimeModule())
+ .addModule(new RFC3339JavaTimeModule())
+ .build();
+ {{#joda}}
+ mapper.registerModule(new JodaModule());
+ {{/joda}}
+ {{#openApiNullable}}
+ mapper.registerModule(new JsonNullableModule());
+ {{/openApiNullable}}
+ {{/useJackson3}}
+ {{#useJackson3}}
+ JsonMapper.Builder jsonMapperBuilder = JsonMapper.builder()
+ .changeDefaultPropertyInclusion(v -> v.withValueInclusion(JsonInclude.Include.NON_NULL))
+ .disable(MapperFeature.ALLOW_COERCION_OF_SCALARS)
+ {{#failOnUnknownProperties}}
+ .enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+ {{/failOnUnknownProperties}}
+ {{^failOnUnknownProperties}}
+ .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+ {{/failOnUnknownProperties}}
+ .enable(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE)
+ .disable(DateTimeFeature.WRITE_DATES_AS_TIMESTAMPS)
+ .enable(EnumFeature.WRITE_ENUMS_USING_TO_STRING)
+ .enable(EnumFeature.READ_ENUMS_USING_TO_STRING)
+ .defaultDateFormat(new RFC3339DateFormat());
+ {{#joda}}
+ jsonMapperBuilder.addModule(new JodaModule());
+ {{/joda}}
+ {{#openApiNullable}}
+ jsonMapperBuilder.addModule(new JsonNullableJackson3Module());
+ {{/openApiNullable}}
+ mapper = jsonMapperBuilder.build();
+ {{/useJackson3}}
+ }
+ {{/isJackson}}
+ {{#isJsonb}}
+ if (jsonb == null) {
+ rebuildJsonb();
+ }
+ {{/isJsonb}}
+ }
+
+ {{#isGson}}
+ private static String getDiscriminatorValue(JsonElement readElement, String discriminatorField) {
+ JsonElement element = readElement.getAsJsonObject().get(discriminatorField);
+ if (null == element) {
+ throw new IllegalArgumentException("missing discriminator field: <" + discriminatorField + ">");
+ }
+ return element.getAsString();
+ }
+
+ private static Class getClassByDiscriminator(Map classByDiscriminatorValue, String discriminatorValue) {
+ Class clazz = (Class) classByDiscriminatorValue.get(discriminatorValue{{^discriminatorCaseSensitive}}.toUpperCase(Locale.ROOT){{/discriminatorCaseSensitive}});
+ if (null == clazz) {
+ throw new IllegalArgumentException("cannot determine model class of name: <" + discriminatorValue + ">");
+ }
+ return clazz;
+ }
+ {{/isGson}}
+ {{#isJackson}}
+ /**
+ * Returns the target model class that should be used to deserialize the input data.
+ * The discriminator mappings are used to determine the target model class.
+ *
+ * @param node The input data.
+ * @param modelClass The class that contains the discriminator mappings.
+ * @return the target model class.
+ */
+ public static Class getClassForElement(JsonNode node, Class modelClass) {
+ ClassDiscriminatorMapping cdm = modelDiscriminators.get(modelClass);
+ if (cdm != null) {
+ return cdm.getClassForElement(node, new HashSet>());
+ }
+ return null;
+ }
+
+ /**
+ * Helper class to register the discriminator mappings.
+ */
+ private static class ClassDiscriminatorMapping {
+ // The model class name.
+ Class modelClass;
+ // The name of the discriminator property.
+ String discriminatorName;
+ // The discriminator mappings for a model class.
+ Map> discriminatorMappings;
+
+ // Constructs a new class discriminator.
+ ClassDiscriminatorMapping(Class cls, String propertyName, Map> mappings) {
+ modelClass = cls;
+ discriminatorName = propertyName;
+ discriminatorMappings = new HashMap>();
+ if (mappings != null) {
+ discriminatorMappings.putAll(mappings);
+ }
+ }
+
+ // Return the name of the discriminator property for this model class.
+ String getDiscriminatorPropertyName() {
+ return discriminatorName;
+ }
+
+ // Return the discriminator value or null if the discriminator is not
+ // present in the payload.
+ String getDiscriminatorValue(JsonNode node) {
+ // Determine the value of the discriminator property in the input data.
+ if (discriminatorName != null) {
+ // Get the value of the discriminator property, if present in the input payload.
+ node = node.get(discriminatorName);
+ if (node != null && node.isValueNode()) {
+ {{^useJackson3}}
+ String discrValue = node.asText();
+ {{/useJackson3}}
+ {{#useJackson3}}
+ String discrValue = node.asString();
+ {{/useJackson3}}
+ if (discrValue != null) {
+ return discrValue;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Returns the target model class that should be used to deserialize the input data.
+ * This function can be invoked for anyOf/oneOf composed models with discriminator mappings.
+ * The discriminator mappings are used to determine the target model class.
+ *
+ * @param node The input data.
+ * @param visitedClasses The set of classes that have already been visited.
+ * @return the target model class.
+ */
+ Class getClassForElement(JsonNode node, Set> visitedClasses) {
+ if (visitedClasses.contains(modelClass)) {
+ // Class has already been visited.
+ return null;
+ }
+ // Determine the value of the discriminator property in the input data.
+ String discrValue = getDiscriminatorValue(node);
+ if (discrValue == null) {
+ return null;
+ }
+ Class cls = discriminatorMappings.get(discrValue);
+ // It may not be sufficient to return this cls directly because that target class
+ // may itself be a composed schema, possibly with its own discriminator.
+ visitedClasses.add(modelClass);
+ for (Class childClass : discriminatorMappings.values()) {
+ ClassDiscriminatorMapping childCdm = modelDiscriminators.get(childClass);
+ if (childCdm == null) {
+ continue;
+ }
+ if (!discriminatorName.equals(childCdm.discriminatorName)) {
+ discrValue = getDiscriminatorValue(node);
+ if (discrValue == null) {
+ continue;
+ }
+ }
+ if (childCdm != null) {
+ // Recursively traverse the discriminator mappings.
+ Class childDiscr = childCdm.getClassForElement(node, visitedClasses);
+ if (childDiscr != null) {
+ return childDiscr;
+ }
+ }
+ }
+ return cls;
+ }
+ }
+
+ /**
+ * Returns true if inst is an instance of modelClass in the OpenAPI model hierarchy.
+ *
+ * The Java class hierarchy is not implemented the same way as the OpenAPI model hierarchy,
+ * so it's not possible to use the instanceof keyword.
+ *
+ * @param modelClass A OpenAPI model class.
+ * @param inst The instance object.
+ * @param visitedClasses The set of classes that have already been visited.
+ * @return true if inst is an instance of modelClass in the OpenAPI model hierarchy.
+ */
+ public static boolean isInstanceOf(Class modelClass, Object inst, Set> visitedClasses) {
+ if (modelClass.isInstance(inst)) {
+ // This handles the 'allOf' use case with single parent inheritance.
+ return true;
+ }
+ if (visitedClasses.contains(modelClass)) {
+ // This is to prevent infinite recursion when the composed schemas have
+ // a circular dependency.
+ return false;
+ }
+ visitedClasses.add(modelClass);
+
+ // Traverse the oneOf/anyOf composed schemas.
+ Map> descendants = modelDescendants.get(modelClass);
+ if (descendants != null) {
+ for (Class childType : descendants.values()) {
+ if (isInstanceOf(childType, inst, visitedClasses)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * A map of discriminators for all model classes.
+ */
+ private static Map, ClassDiscriminatorMapping> modelDiscriminators = new HashMap<>();
+
+ /**
+ * A map of oneOf/anyOf descendants for each model class.
+ */
+ private static Map, Map>> modelDescendants = new HashMap<>();
+
+ /**
+ * Register a model class discriminator.
+ *
+ * @param modelClass the model class
+ * @param discriminatorPropertyName the name of the discriminator property
+ * @param mappings a map with the discriminator mappings.
+ */
+ public static void registerDiscriminator(Class modelClass, String discriminatorPropertyName, Map> mappings) {
+ ClassDiscriminatorMapping m = new ClassDiscriminatorMapping(modelClass, discriminatorPropertyName, mappings);
+ modelDiscriminators.put(modelClass, m);
+ }
+
+ /**
+ * Register the oneOf/anyOf descendants of the modelClass.
+ *
+ * @param modelClass the model class
+ * @param descendants a map of oneOf/anyOf descendants.
+ */
+ public static void registerDescendants(Class modelClass, Map> descendants) {
+ modelDescendants.put(modelClass, descendants);
+ }
+ {{/isJackson}}
+
+ /**
+ * Get the internal serialization object.
+ *
+ * @return serialization object
+ */
+ public static Object getSerializer() {
+ {{#isGson}}
+ return gson;
+ {{/isGson}}
+ {{#isJackson}}
+ return mapper;
+ {{/isJackson}}
+ {{#isJsonb}}
+ return jsonb;
+ {{/isJsonb}}
+ }
+
+ /**
+ * Set the internal serialization object.
+ *
+ * @param serializer serialization object
+ */
+ public static void setSerializer(Object serializer) {
+ {{#isGson}}
+ JSON.gson = (Gson) serializer;
+ {{/isGson}}
+ {{#isJackson}}
+ JSON.mapper = (ObjectMapper) serializer;
+ {{/isJackson}}
+ {{#isJsonb}}
+ JSON.jsonb = (Jsonb) serializer;
+ {{/isJsonb}}
+ }
+
+ {{#isJsonb}}
+ /**
+ * Helper class to get the Type of a generic class.
+ */
+ public static class GenericType {
+ private final Type type;
+
+ protected GenericType() {
+ Type superclass = getClass().getGenericSuperclass();
+ this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
+ }
+
+ public Type getType() {
+ return type;
+ }
+ }
+ {{/isJsonb}}
+ {{#isGson}}
+ public static Gson getGson() {
+ return gson;
+ }
+
+ public static void setGson(Gson gson) {
+ JSON.gson = gson;
+ }
+
+ public static void setLenientOnJson(boolean lenientOnJson) {
+ JSON.isLenientOnJson = lenientOnJson;
+ }
+
+ public static void setDateFormat(DateFormat dateFormat) {
+ dateTypeAdapter.setFormat(dateFormat);
+ }
+
+ public static void setSqlDateFormat(DateFormat dateFormat) {
+ sqlDateTypeAdapter.setFormat(dateFormat);
+ }
+
+ public static boolean isInstanceOf(Class type, Object instance, Set> visited) {
+ if (instance == null) {
+ return true;
+ }
+ if (type.isInstance(instance)) {
+ return true;
+ }
+ if (instance instanceof AbstractOpenApiSchema) {
+ AbstractOpenApiSchema schema = (AbstractOpenApiSchema) instance;
+ visited.add(schema.getClass());
+ for (Class allowedType : schema.getSchemas().values()) {
+ if (visited.contains(allowedType)) {
+ continue;
+ }
+ if (isInstanceOf(type, schema.getActualInstance(), visited)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ {{/isGson}}
+
+ {{#isJackson}}
+ public static ObjectMapper getMapper() {
+ return mapper;
+ }
+
+ public static void setMapper(ObjectMapper mapper) {
+ JSON.mapper = mapper;
+ }
+
+ public static void setDateFormat(DateFormat dateFormat) {
+ {{^useJackson3}}
+ mapper.setDateFormat(dateFormat);
+ {{/useJackson3}}
+ {{#useJackson3}}
+ mapper = ((JsonMapper) mapper).rebuild().defaultDateFormat(dateFormat).build();
+ {{/useJackson3}}
+ }
+
+ public static void setSqlDateFormat(DateFormat dateFormat) {
+ {{^useJackson3}}
+ mapper.registerModule(new SimpleModule().addSerializer(java.sql.Date.class, new JsonSerializer() {
+ @Override
+ public void serialize(java.sql.Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
+ gen.writeString(dateFormat.format(value));
+ }
+ }).addDeserializer(java.sql.Date.class, new JsonDeserializer() {
+ @Override
+ public java.sql.Date deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+ try {
+ return new java.sql.Date(dateFormat.parse(p.getText()).getTime());
+ } catch (java.text.ParseException e) {
+ throw new IOException(e);
+ }
+ }
+ }));
+ {{/useJackson3}}
+ {{#useJackson3}}
+ mapper = ((JsonMapper) mapper).rebuild()
+ .addModule(new SimpleModule().addSerializer(java.sql.Date.class, new ValueSerializer() {
+ @Override
+ public void serialize(java.sql.Date value, JsonGenerator gen, SerializationContext serializers) throws JacksonException {
+ gen.writeString(dateFormat.format(value));
+ }
+ }).addDeserializer(java.sql.Date.class, new ValueDeserializer() {
+ @Override
+ public java.sql.Date deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+ try {
+ return new java.sql.Date(dateFormat.parse(p.getString()).getTime());
+ } catch (java.text.ParseException e) {
+ throw new IllegalArgumentException("Failed to parse java.sql.Date", e);
+ }
+ }
+ }))
+ .build();
+ {{/useJackson3}}
+ }
+
+ public static void setLenientOnJson(boolean lenientOnJson) {
+ {{^useJackson3}}
+ mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, lenientOnJson);
+ mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, lenientOnJson);
+ mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, lenientOnJson);
+ {{/useJackson3}}
+ {{#useJackson3}}
+ mapper = ((JsonMapper) mapper).rebuild()
+ .configure(JsonReadFeature.ALLOW_UNQUOTED_PROPERTY_NAMES, lenientOnJson)
+ .configure(JsonReadFeature.ALLOW_SINGLE_QUOTES, lenientOnJson)
+ .configure(JsonReadFeature.ALLOW_JAVA_COMMENTS, lenientOnJson)
+ .build();
+ {{/useJackson3}}
+ }
+ {{/isJackson}}
+
+ {{#isJsonb}}
+ public static Jsonb getJsonb() {
+ return jsonb;
+ }
+
+ public static void setJsonb(Jsonb jsonb) {
+ JSON.jsonb = jsonb;
+ }
+
+ /**
+ * Rebuild the Jsonb instance from the currently configured formats.
+ *
+ * A Jsonb instance cannot be reconfigured after it is built, so every format setter
+ * records its formatter and calls this method. Any instance previously supplied through
+ * {@link #setJsonb(Jsonb)} is replaced.
+ */
+ private static void rebuildJsonb() {
+ JsonbConfig config = new JsonbConfig();
+ if (dateFormat != null) {
+ config.withAdapters(new DateAdapter(dateFormat));
+ }
+ if (sqlDateFormat != null) {
+ config.withAdapters(new SqlDateAdapter(sqlDateFormat));
+ }
+ {{#jsr310}}
+ if (offsetDateTimeFormat != null) {
+ config.withAdapters(new OffsetDateTimeAdapter(offsetDateTimeFormat));
+ }
+ if (localDateFormat != null) {
+ config.withAdapters(new LocalDateAdapter(localDateFormat));
+ }
+ if (localDateTimeFormat != null) {
+ config.withAdapters(new LocalDateTimeAdapter(localDateTimeFormat));
+ }
+ {{/jsr310}}
+ {{#joda}}
+ if (dateTimeFormat != null) {
+ config.withAdapters(new JodaDateTimeAdapter(dateTimeFormat));
+ }
+ if (jodaLocalDateFormat != null) {
+ config.withAdapters(new JodaLocalDateAdapter(jodaLocalDateFormat));
+ }
+ {{/joda}}
+ jsonb = JsonbBuilder.create(config);
+ }
+
+ public static void setDateFormat(DateFormat dateFormat) {
+ JSON.dateFormat = dateFormat;
+ rebuildJsonb();
+ }
+
+ public static void setSqlDateFormat(DateFormat dateFormat) {
+ JSON.sqlDateFormat = dateFormat;
+ rebuildJsonb();
+ }
+
+ {{! JSON-B has no equivalent of Gson's lenient mode or Jackson's ALLOW_* read features, so this
+ setter is not generated for JSON-B; ApiClient omits its wrapper too. }}
+
+ /**
+ * JSON-B adapter for java.util.Date driven by a configurable DateFormat.
+ */
+ private static class DateAdapter implements JsonbAdapter {
+ private final DateFormat dateFormat;
+
+ DateAdapter(DateFormat dateFormat) {
+ this.dateFormat = dateFormat;
+ }
+
+ @Override
+ public String adaptToJson(Date date) {
+ if (date == null) {
+ return null;
+ }
+ // DateFormat is not thread-safe.
+ synchronized (dateFormat) {
+ return dateFormat.format(date);
+ }
+ }
+
+ @Override
+ public Date adaptFromJson(String value) throws ParseException {
+ if (value == null) {
+ return null;
+ }
+ synchronized (dateFormat) {
+ return dateFormat.parse(value);
+ }
+ }
+ }
+
+ /**
+ * JSON-B adapter for java.sql.Date driven by a configurable DateFormat.
+ */
+ private static class SqlDateAdapter implements JsonbAdapter {
+ private final DateFormat dateFormat;
+
+ SqlDateAdapter(DateFormat dateFormat) {
+ this.dateFormat = dateFormat;
+ }
+
+ @Override
+ public String adaptToJson(java.sql.Date date) {
+ if (date == null) {
+ return null;
+ }
+ synchronized (dateFormat) {
+ return dateFormat.format(date);
+ }
+ }
+
+ @Override
+ public java.sql.Date adaptFromJson(String value) throws ParseException {
+ if (value == null) {
+ return null;
+ }
+ synchronized (dateFormat) {
+ return new java.sql.Date(dateFormat.parse(value).getTime());
+ }
+ }
+ }
+ {{#jsr310}}
+
+ /**
+ * JSON-B adapter for java.time.OffsetDateTime driven by a configurable DateTimeFormatter.
+ */
+ private static class OffsetDateTimeAdapter implements JsonbAdapter {
+ private final DateTimeFormatter formatter;
+
+ OffsetDateTimeAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ @Override
+ public String adaptToJson(OffsetDateTime value) {
+ return value == null ? null : formatter.format(value);
+ }
+
+ @Override
+ public OffsetDateTime adaptFromJson(String value) {
+ return value == null ? null : OffsetDateTime.parse(value, formatter);
+ }
+ }
+
+ /**
+ * JSON-B adapter for java.time.LocalDate driven by a configurable DateTimeFormatter.
+ */
+ private static class LocalDateAdapter implements JsonbAdapter {
+ private final DateTimeFormatter formatter;
+
+ LocalDateAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ @Override
+ public String adaptToJson(LocalDate value) {
+ return value == null ? null : formatter.format(value);
+ }
+
+ @Override
+ public LocalDate adaptFromJson(String value) {
+ return value == null ? null : LocalDate.parse(value, formatter);
+ }
+ }
+
+ /**
+ * JSON-B adapter for java.time.LocalDateTime driven by a configurable DateTimeFormatter.
+ */
+ private static class LocalDateTimeAdapter implements JsonbAdapter {
+ private final DateTimeFormatter formatter;
+
+ LocalDateTimeAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ @Override
+ public String adaptToJson(LocalDateTime value) {
+ return value == null ? null : formatter.format(value);
+ }
+
+ @Override
+ public LocalDateTime adaptFromJson(String value) {
+ return value == null ? null : LocalDateTime.parse(value, formatter);
+ }
+ }
+ {{/jsr310}}
+ {{#joda}}
+
+ /**
+ * JSON-B adapter for org.joda.time.DateTime driven by a configurable DateTimeFormatter.
+ */
+ private static class JodaDateTimeAdapter implements JsonbAdapter {
+ private final DateTimeFormatter formatter;
+
+ JodaDateTimeAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ @Override
+ public String adaptToJson(DateTime value) {
+ return value == null ? null : formatter.print(value);
+ }
+
+ @Override
+ public DateTime adaptFromJson(String value) {
+ return value == null ? null : formatter.parseDateTime(value);
+ }
+ }
+
+ /**
+ * JSON-B adapter for org.joda.time.LocalDate driven by a configurable DateTimeFormatter.
+ */
+ private static class JodaLocalDateAdapter implements JsonbAdapter {
+ private final DateTimeFormatter formatter;
+
+ JodaLocalDateAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ @Override
+ public String adaptToJson(LocalDate value) {
+ return value == null ? null : formatter.print(value);
+ }
+
+ @Override
+ public LocalDate adaptFromJson(String value) {
+ return value == null ? null : formatter.parseLocalDate(value);
+ }
+ }
+ {{/joda}}
+
+ public static boolean isInstanceOf(Class type, Object instance, Set> visited) {
+ if (instance == null) {
+ return true;
+ }
+ if (type.isInstance(instance)) {
+ return true;
+ }
+ if (instance instanceof AbstractOpenApiSchema) {
+ AbstractOpenApiSchema schema = (AbstractOpenApiSchema) instance;
+ visited.add(schema.getClass());
+ for (Class allowedType : schema.getSchemas().values()) {
+ if (visited.contains(allowedType)) {
+ continue;
+ }
+ if (isInstanceOf(type, schema.getActualInstance(), visited)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ {{/isJsonb}}
+
+ {{#jsr310}}
+ {{#isGson}}
+ public static void setOffsetDateTimeFormat(DateTimeFormatter dateFormat) {
+ offsetDateTimeTypeAdapter.setFormat(dateFormat);
+ }
+
+ public static void setLocalDateFormat(DateTimeFormatter dateFormat) {
+ localDateTypeAdapter.setFormat(dateFormat);
+ }
+ {{/isGson}}
+ {{#isJackson}}
+ public static void setOffsetDateTimeFormat(DateTimeFormatter dateFormat) {
+ {{^useJackson3}}
+ mapper.registerModule(new SimpleModule()
+ .addSerializer(OffsetDateTime.class, new JsonSerializer() {
+ @Override
+ public void serialize(OffsetDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
+ gen.writeString(dateFormat.format(value));
+ }
+ })
+ .addDeserializer(OffsetDateTime.class, new JsonDeserializer() {
+ @Override
+ public OffsetDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+ return OffsetDateTime.parse(p.getText(), dateFormat);
+ }
+ }));
+ {{/useJackson3}}
+ {{#useJackson3}}
+ mapper = ((JsonMapper) mapper).rebuild()
+ .addModule(new SimpleModule()
+ .addSerializer(OffsetDateTime.class, new ValueSerializer() {
+ @Override
+ public void serialize(OffsetDateTime value, JsonGenerator gen, SerializationContext serializers) throws JacksonException {
+ gen.writeString(dateFormat.format(value));
+ }
+ })
+ .addDeserializer(OffsetDateTime.class, new ValueDeserializer() {
+ @Override
+ public OffsetDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+ return OffsetDateTime.parse(p.getString(), dateFormat);
+ }
+ }))
+ .build();
+ {{/useJackson3}}
+ }
+
+ public static void setLocalDateFormat(DateTimeFormatter dateFormat) {
+ {{^useJackson3}}
+ mapper.registerModule(new SimpleModule()
+ .addSerializer(LocalDate.class, new JsonSerializer() {
+ @Override
+ public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
+ gen.writeString(dateFormat.format(value));
+ }
+ })
+ .addDeserializer(LocalDate.class, new JsonDeserializer() {
+ @Override
+ public LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+ return LocalDate.parse(p.getText(), dateFormat);
+ }
+ }));
+ {{/useJackson3}}
+ {{#useJackson3}}
+ mapper = ((JsonMapper) mapper).rebuild()
+ .addModule(new SimpleModule()
+ .addSerializer(LocalDate.class, new ValueSerializer() {
+ @Override
+ public void serialize(LocalDate value, JsonGenerator gen, SerializationContext serializers) throws JacksonException {
+ gen.writeString(dateFormat.format(value));
+ }
+ })
+ .addDeserializer(LocalDate.class, new ValueDeserializer() {
+ @Override
+ public LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+ return LocalDate.parse(p.getString(), dateFormat);
+ }
+ }))
+ .build();
+ {{/useJackson3}}
+ }
+ {{/isJackson}}
+ {{#isJsonb}}
+ public static void setOffsetDateTimeFormat(DateTimeFormatter dateFormat) {
+ JSON.offsetDateTimeFormat = dateFormat;
+ rebuildJsonb();
+ }
+
+ public static void setLocalDateFormat(DateTimeFormatter dateFormat) {
+ JSON.localDateFormat = dateFormat;
+ rebuildJsonb();
+ }
+
+ public static void setLocalDateTimeFormat(DateTimeFormatter dateFormat) {
+ JSON.localDateTimeFormat = dateFormat;
+ rebuildJsonb();
+ }
+ {{/isJsonb}}
+ {{/jsr310}}
+
+ {{#joda}}
+ {{#isGson}}
+ public static void setDateTimeFormat(DateTimeFormatter dateFormat) {
+ dateTimeTypeAdapter.setFormat(dateFormat);
+ }
+
+ public static void setLocalDateFormat(DateTimeFormatter dateFormat) {
+ localDateTypeAdapter.setFormat(dateFormat);
+ }
+ {{/isGson}}
+ {{#isJackson}}
+ public static void setDateTimeFormat(org.joda.time.format.DateTimeFormatter dateFormat) {
+ {{^useJackson3}}
+ mapper.registerModule(new SimpleModule()
+ .addSerializer(DateTime.class, new JsonSerializer() {
+ @Override
+ public void serialize(DateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
+ gen.writeString(dateFormat.print(value));
+ }
+ })
+ .addDeserializer(DateTime.class, new JsonDeserializer() {
+ @Override
+ public DateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+ return dateFormat.parseDateTime(p.getText());
+ }
+ }));
+ {{/useJackson3}}
+ {{#useJackson3}}
+ mapper = ((JsonMapper) mapper).rebuild()
+ .addModule(new SimpleModule()
+ .addSerializer(DateTime.class, new ValueSerializer() {
+ @Override
+ public void serialize(DateTime value, JsonGenerator gen, SerializationContext serializers) throws JacksonException {
+ gen.writeString(dateFormat.print(value));
+ }
+ })
+ .addDeserializer(DateTime.class, new ValueDeserializer() {
+ @Override
+ public DateTime deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+ return dateFormat.parseDateTime(p.getString());
+ }
+ }))
+ .build();
+ {{/useJackson3}}
+ }
+
+ public static void setLocalDateFormat(org.joda.time.format.DateTimeFormatter dateFormat) {
+ {{^useJackson3}}
+ mapper.registerModule(new SimpleModule()
+ .addSerializer(org.joda.time.LocalDate.class, new JsonSerializer() {
+ @Override
+ public void serialize(org.joda.time.LocalDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
+ gen.writeString(dateFormat.print(value));
+ }
+ })
+ .addDeserializer(org.joda.time.LocalDate.class, new JsonDeserializer() {
+ @Override
+ public org.joda.time.LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
+ return dateFormat.parseLocalDate(p.getText());
+ }
+ }));
+ {{/useJackson3}}
+ {{#useJackson3}}
+ mapper = ((JsonMapper) mapper).rebuild()
+ .addModule(new SimpleModule()
+ .addSerializer(org.joda.time.LocalDate.class, new ValueSerializer() {
+ @Override
+ public void serialize(org.joda.time.LocalDate value, JsonGenerator gen, SerializationContext serializers) throws JacksonException {
+ gen.writeString(dateFormat.print(value));
+ }
+ })
+ .addDeserializer(org.joda.time.LocalDate.class, new ValueDeserializer() {
+ @Override
+ public org.joda.time.LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws JacksonException {
+ return dateFormat.parseLocalDate(p.getString());
+ }
+ }))
+ .build();
+ {{/useJackson3}}
+ }
+ {{/isJackson}}
+ {{#isJsonb}}
+ public static void setDateTimeFormat(DateTimeFormatter dateFormat) {
+ JSON.dateTimeFormat = dateFormat;
+ rebuildJsonb();
+ }
+
+ public static void setLocalDateFormat(DateTimeFormatter dateFormat) {
+ JSON.jodaLocalDateFormat = dateFormat;
+ rebuildJsonb();
+ }
+ {{/isJsonb}}
+ {{/joda}}
+
+ /**
+ * Serialize the given Java object into JSON string.
+ *
+ * @param obj Object
+ * @return String representation of the JSON
+ */
+ public String serialize(Object obj) {
+ {{#isGson}}
+ return gson.toJson(obj);
+ {{/isGson}}
+ {{#isJackson}}
+ try {
+ return mapper.writeValueAsString(obj);
+ } catch ({{#useJackson3}}JacksonException{{/useJackson3}}{{^useJackson3}}IOException{{/useJackson3}} e) {
+ throw new RuntimeException(e);
+ }
+ {{/isJackson}}
+ {{#isJsonb}}
+ return jsonb.toJson(obj);
+ {{/isJsonb}}
+ }
+
+ /**
+ * Deserialize the given JSON string to Java object.
+ *
+ * @param Type
+ * @param body The JSON string
+ * @param returnType The type to deserialize into
+ * @return The deserialized Java object
+ */
+ @SuppressWarnings("unchecked")
+ public T deserialize(String body, Type returnType) {
+ {{#isGson}}
+ try {
+ if (isLenientOnJson) {
+ JsonReader jsonReader = new JsonReader(new StringReader(body));
+ jsonReader.setLenient(true);
+ return gson.fromJson(jsonReader, returnType);
+ } else {
+ return gson.fromJson(body, returnType);
+ }
+ } catch (JsonParseException e) {
+ if (returnType.equals(String.class)) {
+ return (T) body;
+ } else {
+ throw (e);
+ }
+ }
+ {{/isGson}}
+ {{#isJackson}}
+ try {
+ JavaType type = mapper.getTypeFactory().constructType(returnType);
+ return mapper.readValue(body, type);
+ } catch ({{#useJackson3}}JacksonException{{/useJackson3}}{{^useJackson3}}IOException{{/useJackson3}} e) {
+ if (returnType.equals(String.class)) {
+ return (T) body;
+ } else {
+ throw new RuntimeException(e);
+ }
+ }
+ {{/isJackson}}
+ {{#isJsonb}}
+ return jsonb.fromJson(body, returnType);
+ {{/isJsonb}}
+ }
+
+ /**
+ * Deserialize the given JSON InputStream to a Java object.
+ *
+ * @param Type
+ * @param inputStream The JSON InputStream
+ * @param returnType The type to deserialize into
+ * @return The deserialized Java object
+ */
+ @SuppressWarnings("unchecked")
+ public T deserialize(InputStream inputStream, Type returnType) throws IOException {
+ {{#isGson}}
+ try (InputStreamReader reader = new InputStreamReader(inputStream, StandardCharsets.UTF_8)) {
+ if (isLenientOnJson) {
+ JsonReader jsonReader = new JsonReader(reader);
+ jsonReader.setLenient(true);
+ return gson.fromJson(jsonReader, returnType);
+ } else {
+ return gson.fromJson(reader, returnType);
+ }
+ }
+ {{/isGson}}
+ {{#isJackson}}
+ JavaType type = mapper.getTypeFactory().constructType(returnType);
+ return mapper.readValue(inputStream, type);
+ {{/isJackson}}
+ {{#isJsonb}}
+ return jsonb.fromJson(inputStream, returnType);
+ {{/isJsonb}}
+ }
+
+ {{#isGson}}
+ /**
+ * Gson TypeAdapter for Byte Array type
+ */
+ public static class ByteArrayAdapter extends TypeAdapter {
+
+ @Override
+ public void write(JsonWriter out, byte[] value) throws IOException {
+ if (value == null) {
+ out.nullValue();
+ } else {
+ out.value(ByteString.of(value).base64());
+ }
+ }
+
+ @Override
+ public byte[] read(JsonReader in) throws IOException {
+ switch (in.peek()) {
+ case NULL:
+ in.nextNull();
+ return null;
+ default:
+ String bytesAsBase64 = in.nextString();
+ ByteString byteString = ByteString.decodeBase64(bytesAsBase64);
+ return byteString.toByteArray();
+ }
+ }
+ }
+ {{#joda}}
+ /**
+ * Gson TypeAdapter for Joda DateTime type
+ */
+ public static class DateTimeTypeAdapter extends TypeAdapter {
+
+ private DateTimeFormatter formatter;
+
+ public DateTimeTypeAdapter() {
+ this(new DateTimeFormatterBuilder()
+ .append(ISODateTimeFormat.dateTime().getPrinter(), ISODateTimeFormat.dateOptionalTimeParser().getParser())
+ .toFormatter());
+ }
+
+ public DateTimeTypeAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ public void setFormat(DateTimeFormatter dateFormat) {
+ this.formatter = dateFormat;
+ }
+
+ @Override
+ public void write(JsonWriter out, DateTime date) throws IOException {
+ if (date == null) {
+ out.nullValue();
+ } else {
+ out.value(formatter.print(date));
+ }
+ }
+
+ @Override
+ public DateTime read(JsonReader in) throws IOException {
+ switch (in.peek()) {
+ case NULL:
+ in.nextNull();
+ return null;
+ default:
+ String date = in.nextString();
+ return formatter.parseDateTime(date);
+ }
+ }
+ }
+
+ /**
+ * Gson TypeAdapter for Joda LocalDate type
+ */
+ public static class LocalDateTypeAdapter extends TypeAdapter {
+
+ private DateTimeFormatter formatter;
+
+ public LocalDateTypeAdapter() {
+ this(ISODateTimeFormat.date());
+ }
+
+ public LocalDateTypeAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ public void setFormat(DateTimeFormatter dateFormat) {
+ this.formatter = dateFormat;
+ }
+
+ @Override
+ public void write(JsonWriter out, LocalDate date) throws IOException {
+ if (date == null) {
+ out.nullValue();
+ } else {
+ out.value(formatter.print(date));
+ }
+ }
+
+ @Override
+ public LocalDate read(JsonReader in) throws IOException {
+ switch (in.peek()) {
+ case NULL:
+ in.nextNull();
+ return null;
+ default:
+ String date = in.nextString();
+ return formatter.parseLocalDate(date);
+ }
+ }
+ }
+
+ {{/joda}}
+ {{#jsr310}}
+ /**
+ * Gson TypeAdapter for JSR310 OffsetDateTime type
+ */
+ public static class OffsetDateTimeTypeAdapter extends TypeAdapter {
+
+ private DateTimeFormatter formatter;
+
+ public OffsetDateTimeTypeAdapter() {
+ this(DateTimeFormatter.ISO_OFFSET_DATE_TIME);
+ }
+
+ public OffsetDateTimeTypeAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ public void setFormat(DateTimeFormatter dateFormat) {
+ this.formatter = dateFormat;
+ }
+
+ @Override
+ public void write(JsonWriter out, OffsetDateTime date) throws IOException {
+ if (date == null) {
+ out.nullValue();
+ } else {
+ out.value(formatter.format(date));
+ }
+ }
+
+ @Override
+ public OffsetDateTime read(JsonReader in) throws IOException {
+ switch (in.peek()) {
+ case NULL:
+ in.nextNull();
+ return null;
+ default:
+ String date = in.nextString();
+ if (date.endsWith("+0000")) {
+ date = date.substring(0, date.length()-5) + "Z";
+ }
+ return OffsetDateTime.parse(date, formatter);
+ }
+ }
+ }
+
+ /**
+ * Gson TypeAdapter for JSR310 LocalDate type
+ */
+ public static class LocalDateTypeAdapter extends TypeAdapter {
+
+ private DateTimeFormatter formatter;
+
+ public LocalDateTypeAdapter() {
+ this(DateTimeFormatter.ISO_LOCAL_DATE);
+ }
+
+ public LocalDateTypeAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ public void setFormat(DateTimeFormatter dateFormat) {
+ this.formatter = dateFormat;
+ }
+
+ @Override
+ public void write(JsonWriter out, LocalDate date) throws IOException {
+ if (date == null) {
+ out.nullValue();
+ } else {
+ out.value(formatter.format(date));
+ }
+ }
+
+ @Override
+ public LocalDate read(JsonReader in) throws IOException {
+ switch (in.peek()) {
+ case NULL:
+ in.nextNull();
+ return null;
+ default:
+ String date = in.nextString();
+ return LocalDate.parse(date, formatter);
+ }
+ }
+ }
+
+ /**
+ * Gson TypeAdapter for JSR310 LocalDateTime type
+ */
+ public static class LocalDateTimeTypeAdapter extends TypeAdapter {
+
+ private DateTimeFormatter formatter;
+
+ public LocalDateTimeTypeAdapter() {
+ this(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
+ }
+
+ public LocalDateTimeTypeAdapter(DateTimeFormatter formatter) {
+ this.formatter = formatter;
+ }
+
+ public void setFormat(DateTimeFormatter dateFormat) {
+ this.formatter = dateFormat;
+ }
+
+ @Override
+ public void write(JsonWriter out, LocalDateTime date) throws IOException {
+ if (date == null) {
+ out.nullValue();
+ } else {
+ out.value(formatter.format(date));
+ }
+ }
+
+ @Override
+ public LocalDateTime read(JsonReader in) throws IOException {
+ switch (in.peek()) {
+ case NULL:
+ in.nextNull();
+ return null;
+ default:
+ String date = in.nextString();
+ try {
+ return LocalDateTime.parse(date, formatter);
+ } catch (DateTimeParseException e) {
+ if (date.length() > 10 && date.charAt(10) == ' ') {
+ date = date.substring(0, 10) + 'T' + date.substring(11);
+ return LocalDateTime.parse(date, formatter);
+ }
+ throw e;
+ }
+ }
+ }
+ }
+
+ public static void setLocalDateTimeFormat(DateTimeFormatter dateFormat) {
+ localDateTimeTypeAdapter.setFormat(dateFormat);
+ }
+
+ {{/jsr310}}
+ /**
+ * Gson TypeAdapter for java.sql.Date type
+ * If the dateFormat is null, a simple "yyyy-MM-dd" format will be used
+ * (more efficient than SimpleDateFormat).
+ */
+ public static class SqlDateTypeAdapter extends TypeAdapter {
+
+ private DateFormat dateFormat;
+
+ public SqlDateTypeAdapter() {}
+
+ public SqlDateTypeAdapter(DateFormat dateFormat) {
+ this.dateFormat = dateFormat;
+ }
+
+ public void setFormat(DateFormat dateFormat) {
+ this.dateFormat = dateFormat;
+ }
+
+ @Override
+ public void write(JsonWriter out, java.sql.Date date) throws IOException {
+ if (date == null) {
+ out.nullValue();
+ } else {
+ String value;
+ if (dateFormat != null) {
+ value = dateFormat.format(date);
+ } else {
+ value = date.toString();
+ }
+ out.value(value);
+ }
+ }
+
+ @Override
+ public java.sql.Date read(JsonReader in) throws IOException {
+ switch (in.peek()) {
+ case NULL:
+ in.nextNull();
+ return null;
+ default:
+ String date = in.nextString();
+ try {
+ if (dateFormat != null) {
+ return new java.sql.Date(dateFormat.parse(date).getTime());
+ }
+ return new java.sql.Date(ISO8601Utils.parse(date, new ParsePosition(0)).getTime());
+ } catch (ParseException e) {
+ throw new JsonParseException(e);
+ }
+ }
+ }
+ }
+
+ /**
+ * Gson TypeAdapter for java.util.Date type
+ * If the dateFormat is null, ISO8601Utils will be used.
+ */
+ public static class DateTypeAdapter extends TypeAdapter {
+
+ private DateFormat dateFormat;
+
+ public DateTypeAdapter() {}
+
+ public DateTypeAdapter(DateFormat dateFormat) {
+ this.dateFormat = dateFormat;
+ }
+
+ public void setFormat(DateFormat dateFormat) {
+ this.dateFormat = dateFormat;
+ }
+
+ @Override
+ public void write(JsonWriter out, Date date) throws IOException {
+ if (date == null) {
+ out.nullValue();
+ } else {
+ String value;
+ if (dateFormat != null) {
+ value = dateFormat.format(date);
+ } else {
+ value = ISO8601Utils.format(date, true);
+ }
+ out.value(value);
+ }
+ }
+
+ @Override
+ public Date read(JsonReader in) throws IOException {
+ try {
+ switch (in.peek()) {
+ case NULL:
+ in.nextNull();
+ return null;
+ default:
+ String date = in.nextString();
+ try {
+ if (dateFormat != null) {
+ return dateFormat.parse(date);
+ }
+ return ISO8601Utils.parse(date, new ParsePosition(0));
+ } catch (ParseException e) {
+ throw new JsonParseException(e);
+ }
+ }
+ } catch (IllegalArgumentException e) {
+ throw new JsonParseException(e);
+ }
+ }
+ }
+ {{/isGson}}
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/ProgressRequestBody.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/ProgressRequestBody.mustache
new file mode 100644
index 000000000000..423d40aece62
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/ProgressRequestBody.mustache
@@ -0,0 +1,72 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}};
+
+import okhttp3.MediaType;
+import okhttp3.RequestBody;
+
+import java.io.IOException;
+import java.util.Objects;
+
+import okio.Buffer;
+import okio.BufferedSink;
+import okio.ForwardingSink;
+import okio.Okio;
+import okio.Sink;
+
+public class ProgressRequestBody extends RequestBody {
+
+ private final RequestBody requestBody;
+
+ private final ApiCallback callback;
+
+ public ProgressRequestBody(RequestBody requestBody, ApiCallback callback) {
+ this.requestBody = requestBody;
+ this.callback = Objects.requireNonNull(callback);
+ }
+
+ @Override
+ public MediaType contentType() {
+ return requestBody.contentType();
+ }
+
+ @Override
+ public long contentLength() throws IOException {
+ return requestBody.contentLength();
+ }
+
+ @Override
+ public void writeTo(BufferedSink sink) throws IOException {
+ CountingSink countingSink = new CountingSink(sink);
+ BufferedSink bufferedSink = Okio.buffer(countingSink);
+ requestBody.writeTo(bufferedSink);
+ bufferedSink.flush();
+
+ long bytesWritten = countingSink.bytesWritten;
+ long contentLength = contentLength();
+ callback.onUploadProgress(bytesWritten, contentLength, true);
+ }
+
+ private final class CountingSink extends ForwardingSink {
+
+ private long bytesWritten = 0L;
+ private long contentLength = 0L;
+
+ public CountingSink(Sink delegate) {
+ super(delegate);
+ }
+
+ @Override
+ public void write(Buffer source, long byteCount) throws IOException {
+ super.write(source, byteCount);
+ if (contentLength == 0) {
+ contentLength = contentLength();
+ }
+
+ bytesWritten += byteCount;
+ // writeTo emits the single terminal callback once the body is fully written; reporting
+ // done here as well would fire it twice for a known-length body.
+ callback.onUploadProgress(bytesWritten, contentLength, false);
+ }
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/ProgressResponseBody.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/ProgressResponseBody.mustache
new file mode 100644
index 000000000000..eaffa96d327b
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/ProgressResponseBody.mustache
@@ -0,0 +1,61 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}};
+
+import okhttp3.MediaType;
+import okhttp3.ResponseBody;
+
+import java.io.IOException;
+
+import okio.Buffer;
+import okio.BufferedSource;
+import okio.ForwardingSource;
+import okio.Okio;
+import okio.Source;
+
+public class ProgressResponseBody extends ResponseBody {
+
+ private final ResponseBody responseBody;
+ private final ApiCallback callback;
+ private BufferedSource bufferedSource;
+
+ public ProgressResponseBody(ResponseBody responseBody, ApiCallback callback) {
+ this.responseBody = responseBody;
+ this.callback = callback;
+ }
+
+ @Override
+ public MediaType contentType() {
+ return responseBody.contentType();
+ }
+
+ @Override
+ public long contentLength() {
+ return responseBody.contentLength();
+ }
+
+ @Override
+ public BufferedSource source() {
+ // Memoized: OkHttp calls source() again on close(), and a second ForwardingSource would
+ // reset the progress counter and re-wrap an already partially consumed stream.
+ if (bufferedSource == null) {
+ bufferedSource = Okio.buffer(source(responseBody.source()));
+ }
+ return bufferedSource;
+ }
+
+ private Source source(Source source) {
+ return new ForwardingSource(source) {
+ long totalBytesRead = 0L;
+
+ @Override
+ public long read(Buffer sink, long byteCount) throws IOException {
+ long bytesRead = super.read(sink, byteCount);
+ // read() returns the number of bytes read, or -1 if this source is exhausted.
+ totalBytesRead += bytesRead != -1 ? bytesRead : 0;
+ callback.onDownloadProgress(totalBytesRead, responseBody.contentLength(), bytesRead == -1);
+ return bytesRead;
+ }
+ };
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/README.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/README.mustache
new file mode 100644
index 000000000000..de3afa6c1875
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/README.mustache
@@ -0,0 +1,195 @@
+# {{artifactId}}
+
+{{appName}}
+- API version: {{appVersion}}
+{{^hideGenerationTimestamp}}
+ - Build date: {{generatedDate}}
+{{/hideGenerationTimestamp}}
+ - Generator version: {{generatorVersion}}
+
+{{{appDescriptionWithNewLines}}}
+
+{{#infoUrl}}
+ For more information, please visit [{{{infoUrl}}}]({{{infoUrl}}})
+{{/infoUrl}}
+
+*Automatically generated by the [OpenAPI Generator](https://openapi-generator.tech)*
+
+
+## Requirements
+
+Building the API client library requires:
+1. Java 1.8+
+2. Maven (3.8.3+)/Gradle (7.2+)
+
+## Installation
+
+To install the API client library to your local Maven repository, simply execute:
+
+```shell
+mvn clean install
+```
+
+To deploy it to a remote Maven repository instead, configure the settings of the repository and execute:
+
+```shell
+mvn clean deploy
+```
+
+Refer to the [OSSRH Guide](http://central.sonatype.org/pages/ossrh-guide.html) for more information.
+
+### Maven users
+
+Add this dependency to your project's POM:
+
+```xml
+
+ {{{groupId}}}
+ {{{artifactId}}}
+ {{{artifactVersion}}}
+ compile
+
+```
+
+### Gradle users
+
+Add this dependency to your project's build file:
+
+```groovy
+ repositories {
+ mavenCentral() // Needed if the '{{{artifactId}}}' jar has been published to maven central.
+ mavenLocal() // Needed if the '{{{artifactId}}}' jar has been published to the local maven repo.
+ }
+
+ dependencies {
+ implementation "{{{groupId}}}:{{{artifactId}}}:{{{artifactVersion}}}"
+ }
+```
+
+### Others
+
+At first generate the JAR by executing:
+
+```shell
+mvn clean package
+```
+
+Then manually install the following JARs:
+
+* `target/{{{artifactId}}}-{{{artifactVersion}}}.jar`
+* `target/lib/*.jar`
+
+## Getting Started
+
+Please follow the [installation](#installation) instruction and execute the following Java code:
+
+```java
+{{#apiInfo}}{{#apis}}{{#-first}}{{#operations}}{{#operation}}{{#-first}}
+// Import classes:
+import {{{invokerPackage}}}.ApiClient;
+import {{{invokerPackage}}}.ApiException;
+import {{{invokerPackage}}}.Configuration;{{#hasAuthMethods}}
+import {{{invokerPackage}}}.auth.*;{{/hasAuthMethods}}
+import {{{modelPackage}}}.*;
+import {{{package}}}.{{{classname}}};
+
+public class Example {
+ public static void main(String[] args) {
+ ApiClient defaultClient = Configuration.getDefaultApiClient();
+ defaultClient.setBasePath("{{{basePath}}}");
+ {{#withAWSV4Signature}}
+ // Configure AWS Signature V4 authorization
+ defaultClient.setAWS4Configuration("YOUR_ACCESS_KEY", "YOUR_SECRET_KEY", "REGION", "SERVICE")
+ {{/withAWSV4Signature}}
+ {{#hasAuthMethods}}
+ {{#authMethods}}{{#isBasic}}{{#isBasicBasic}}
+ // Configure HTTP basic authorization: {{{name}}}
+ HttpBasicAuth {{{name}}} = (HttpBasicAuth) defaultClient.getAuthentication("{{{name}}}");
+ {{{name}}}.setUsername("YOUR USERNAME");
+ {{{name}}}.setPassword("YOUR PASSWORD");{{/isBasicBasic}}{{#isBasicBearer}}
+ // Configure HTTP bearer authorization: {{{name}}}
+ HttpBearerAuth {{{name}}} = (HttpBearerAuth) defaultClient.getAuthentication("{{{name}}}");
+ {{{name}}}.setBearerToken("BEARER TOKEN");{{/isBasicBearer}}{{/isBasic}}{{#isApiKey}}
+ // Configure API key authorization: {{{name}}}
+ ApiKeyAuth {{{name}}} = (ApiKeyAuth) defaultClient.getAuthentication("{{{name}}}");
+ {{{name}}}.setApiKey("YOUR API KEY");
+ // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
+ //{{{name}}}.setApiKeyPrefix("Token");{{/isApiKey}}{{#isOAuth}}
+ // Configure OAuth2 access token for authorization: {{{name}}}
+ OAuth {{{name}}} = (OAuth) defaultClient.getAuthentication("{{{name}}}");
+ {{{name}}}.setAccessToken("YOUR ACCESS TOKEN");{{/isOAuth}}
+ {{/authMethods}}
+ {{/hasAuthMethods}}
+
+ {{{classname}}} apiInstance = new {{{classname}}}(defaultClient);
+ {{#allParams}}
+ {{{dataType}}} {{{paramName}}} = {{{example}}}; // {{{dataType}}} | {{{description}}}
+ {{/allParams}}
+ try {
+ {{#returnType}}{{{.}}} result = {{/returnType}}apiInstance.{{{operationId}}}{{^vendorExtensions.x-group-parameters}}({{#allParams}}{{{paramName}}}{{^-last}}, {{/-last}}{{/allParams}});{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}({{#requiredParams}}{{{paramName}}}{{^-last}}, {{/-last}}{{/requiredParams}}){{#optionalParams}}
+ .{{{paramName}}}({{{paramName}}}){{/optionalParams}}
+ .execute();{{/vendorExtensions.x-group-parameters}}{{#returnType}}
+ System.out.println(result);{{/returnType}}
+ } catch (ApiException e) {
+ System.err.println("Exception when calling {{{classname}}}#{{{operationId}}}");
+ System.err.println("Status code: " + e.getCode());
+ System.err.println("Reason: " + e.getResponseBody());
+ System.err.println("Response headers: " + e.getResponseHeaders());
+ e.printStackTrace();
+ }
+ }
+}
+{{/-first}}{{/operation}}{{/operations}}{{/-first}}{{/apis}}{{/apiInfo}}
+```
+
+## Documentation for API Endpoints
+
+All URIs are relative to *{{basePath}}*
+
+Class | Method | HTTP request | Description
+------------ | ------------- | ------------- | -------------
+{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}*{{classname}}* | [**{{operationId}}**]({{apiDocPath}}{{classname}}.md#{{operationId}}) | **{{httpMethod}}** {{path}} | {{summary}}
+{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
+
+## Documentation for Models
+
+{{#models}}{{#model}} - [{{classname}}]({{modelDocPath}}{{classname}}.md)
+{{/model}}{{/models}}
+
+
+## Documentation for Authorization
+
+{{^authMethods}}Endpoints do not require authorization.{{/authMethods}}
+{{#hasAuthMethods}}Authentication schemes defined for the API:{{/hasAuthMethods}}
+{{#authMethods}}
+
+### {{name}}
+
+{{#isApiKey}}- **Type**: API key
+- **API key parameter name**: {{keyParamName}}
+- **Location**: {{#isKeyInQuery}}URL query string{{/isKeyInQuery}}{{#isKeyInHeader}}HTTP header{{/isKeyInHeader}}
+{{/isApiKey}}
+{{#isBasicBasic}}- **Type**: HTTP basic authentication
+{{/isBasicBasic}}
+{{#isBasicBearer}}- **Type**: HTTP Bearer Token authentication{{#bearerFormat}} ({{{.}}}){{/bearerFormat}}
+{{/isBasicBearer}}
+{{#isHttpSignature}}- **Type**: HTTP signature authentication
+{{/isHttpSignature}}
+{{#isOAuth}}- **Type**: OAuth
+- **Flow**: {{flow}}
+- **Authorization URL**: {{authorizationUrl}}
+- **Scopes**: {{^scopes}}N/A{{/scopes}}
+{{#scopes}} - {{scope}}: {{description}}
+{{/scopes}}
+{{/isOAuth}}
+
+{{/authMethods}}
+
+## Recommendation
+
+It's recommended to create an instance of `ApiClient` per thread in a multithreaded environment to avoid any potential issues.
+
+## Author
+
+{{#apiInfo}}{{#apis}}{{#-last}}{{infoEmail}}
+{{/-last}}{{/apis}}{{/apiInfo}}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/additional_properties.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/additional_properties.mustache
new file mode 100644
index 000000000000..f3fe50b5d601
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/additional_properties.mustache
@@ -0,0 +1,58 @@
+{{#isAdditionalPropertiesTrue}}
+ /**
+ * A container for additional, undeclared properties.
+ * This is a holder for any undeclared properties as specified with
+ * the 'additionalProperties' keyword in the OAS document.
+ */
+ {{#isJackson}}
+ @JsonIgnore
+ {{/isJackson}}
+ {{#isJsonb}}
+ @JsonbTransient
+ {{/isJsonb}}
+ private Map additionalProperties;
+
+ /**
+ * Set the additional (undeclared) property with the specified name and value.
+ * If the property does not already exist, create it otherwise replace it.
+ *
+ * @param key name of the property
+ * @param value value of the property
+ * @return the {{classname}} instance itself
+ */
+ {{#isJackson}}
+ @JsonAnySetter
+ {{/isJackson}}
+ public {{classname}} putAdditionalProperty(String key, Object value) {
+ if (this.additionalProperties == null) {
+ this.additionalProperties = new HashMap();
+ }
+ this.additionalProperties.put(key, value);
+ return this;
+ }
+
+ /**
+ * Return the additional (undeclared) property.
+ *
+ * @return a map of objects
+ */
+ {{#isJackson}}
+ @JsonAnyGetter
+ {{/isJackson}}
+ public Map getAdditionalProperties() {
+ return additionalProperties;
+ }
+
+ /**
+ * Return the additional (undeclared) property with the specified name.
+ *
+ * @param key name of the property
+ * @return an object
+ */
+ public Object getAdditionalProperty(String key) {
+ if (this.additionalProperties == null) {
+ return null;
+ }
+ return this.additionalProperties.get(key);
+ }
+{{/isAdditionalPropertiesTrue}}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/anyof_model.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/anyof_model.mustache
new file mode 100644
index 000000000000..a6b4ffabbe88
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/anyof_model.mustache
@@ -0,0 +1,970 @@
+{{#isGson}}
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonParseException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.annotations.JsonAdapter;
+import com.google.gson.annotations.SerializedName;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonArray;
+{{/isGson}}
+{{#isJackson}}
+{{#isAdditionalPropertiesTrue}}
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+{{/isAdditionalPropertiesTrue}}
+import {{jacksonPackage}}.core.JsonGenerator;
+import {{jacksonPackage}}.core.JsonParser;
+import {{jacksonPackage}}.core.JsonToken;
+import {{jacksonPackage}}.core.type.TypeReference;
+import {{jacksonPackage}}.databind.DeserializationContext;
+{{^useJackson3}}
+import {{jacksonPackage}}.databind.JsonMappingException;
+{{/useJackson3}}
+import {{jacksonPackage}}.databind.JsonNode;
+import {{jacksonPackage}}.databind.MapperFeature;
+{{^useJackson3}}
+import {{jacksonPackage}}.databind.SerializerProvider;
+{{/useJackson3}}
+import {{jacksonPackage}}.databind.annotation.JsonDeserialize;
+import {{jacksonPackage}}.databind.annotation.JsonSerialize;
+import {{jacksonPackage}}.databind.deser.std.StdDeserializer;
+import {{jacksonPackage}}.databind.ser.std.StdSerializer;
+import {{jacksonPackage}}.databind.JavaType;
+{{#useJackson3}}
+import {{jacksonPackage}}.core.JacksonException;
+import {{jacksonPackage}}.databind.DatabindException;
+import {{jacksonPackage}}.databind.SerializationContext;
+{{/useJackson3}}
+{{/isJackson}}
+
+{{#isJsonb}}
+import jakarta.json.bind.annotation.JsonbTypeDeserializer;
+import jakarta.json.bind.annotation.JsonbTypeSerializer;
+import jakarta.json.bind.serializer.DeserializationContext;
+import jakarta.json.bind.serializer.JsonbDeserializer;
+import jakarta.json.bind.serializer.JsonbSerializer;
+import jakarta.json.bind.serializer.SerializationContext;
+import jakarta.json.stream.JsonGenerator;
+import jakarta.json.stream.JsonParser;
+import jakarta.json.JsonObject;
+{{/isJsonb}}
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.StringJoiner;
+
+import {{invokerPackage}}.JSON;
+
+{{>additionalModelTypeAnnotations}}{{>generatedAnnotation}}{{>xmlAnnotation}}
+{{#isJackson}}
+@JsonDeserialize(using = {{classname}}.{{classname}}Deserializer.class)
+@JsonSerialize(using = {{classname}}.{{classname}}Serializer.class)
+{{/isJackson}}
+{{#isJsonb}}
+@JsonbTypeDeserializer({{classname}}.{{classname}}Deserializer.class)
+@JsonbTypeSerializer({{classname}}.{{classname}}Serializer.class)
+{{/isJsonb}}
+public class {{classname}} extends AbstractOpenApiSchema{{#vendorExtensions.x-implements}} implements {{{.}}}{{^-last}}, {{/-last}}{{/vendorExtensions.x-implements}} {
+ private static final Logger log = Logger.getLogger({{classname}}.class.getName());
+
+{{>additional_properties}}
+ {{#isAdditionalPropertiesTrue}}
+ {{#isGson}}
+ /**
+ * Record the properties that the matched anyOf schema did not consume.
+ *
+ * The wrapper only owns what the selected child schema left behind. When that child accepts
+ * additional properties itself it absorbs them all and this records nothing, so a property is
+ * never stored — and therefore never written — twice.
+ */
+ private static void collectUnconsumedProperties({{classname}} instance, JsonElement jsonElement, Gson gson) {
+ if (jsonElement == null || !jsonElement.isJsonObject() || instance.getActualInstance() == null) {
+ return;
+ }
+ JsonElement consumedElement = gson.toJsonTree(instance.getActualInstance());
+ if (consumedElement == null || !consumedElement.isJsonObject()) {
+ return;
+ }
+ JsonObject consumed = consumedElement.getAsJsonObject();
+ for (Map.Entry entry : jsonElement.getAsJsonObject().entrySet()) {
+ if (consumed.has(entry.getKey())) {
+ continue;
+ }
+ JsonElement value = entry.getValue();
+ if (value.isJsonPrimitive()) {
+ JsonPrimitive primitive = value.getAsJsonPrimitive();
+ if (primitive.isString()) {
+ instance.putAdditionalProperty(entry.getKey(), primitive.getAsString());
+ } else if (primitive.isNumber()) {
+ instance.putAdditionalProperty(entry.getKey(), primitive.getAsNumber());
+ } else if (primitive.isBoolean()) {
+ instance.putAdditionalProperty(entry.getKey(), primitive.getAsBoolean());
+ }
+ } else if (value.isJsonArray()) {
+ instance.putAdditionalProperty(entry.getKey(), gson.fromJson(value, List.class));
+ } else if (value.isJsonObject()) {
+ instance.putAdditionalProperty(entry.getKey(), gson.fromJson(value, HashMap.class));
+ }
+ }
+ }
+
+ /**
+ * Merge the unconsumed properties back into the JSON produced by the matched anyOf schema.
+ */
+ private static void writeUnconsumedProperties({{classname}} value, JsonObject obj, Gson gson) {
+ if (value.getAdditionalProperties() == null) {
+ return;
+ }
+ for (Map.Entry entry : value.getAdditionalProperties().entrySet()) {
+ if (obj.has(entry.getKey())) {
+ // the child schema owns this property
+ continue;
+ }
+ obj.add(entry.getKey(), gson.toJsonTree(entry.getValue()));
+ }
+ }
+ {{/isGson}}
+ {{#isJackson}}
+ /**
+ * Record the properties that the matched anyOf schema did not consume.
+ *
+ * The wrapper only owns what the selected child schema left behind. When that child accepts
+ * additional properties itself it absorbs them all and this records nothing, so a property is
+ * never stored — and therefore never written — twice.
+ */
+ private static void collectUnconsumedProperties({{classname}} instance, JsonNode tree) {
+ if (tree == null || !tree.isObject() || instance.getActualInstance() == null) {
+ return;
+ }
+ JsonNode consumed = JSON.getMapper().valueToTree(instance.getActualInstance());
+ if (consumed == null || !consumed.isObject()) {
+ return;
+ }
+ java.util.Iterator> fields = tree.{{^useJackson3}}fields{{/useJackson3}}{{#useJackson3}}properties{{/useJackson3}}(){{#useJackson3}}.iterator(){{/useJackson3}};
+ while (fields.hasNext()) {
+ Map.Entry entry = fields.next();
+ if (consumed.has(entry.getKey())) {
+ continue;
+ }
+ instance.putAdditionalProperty(entry.getKey(),
+ JSON.getMapper().convertValue(entry.getValue(), Object.class));
+ }
+ }
+ {{/isJackson}}
+ {{/isAdditionalPropertiesTrue}}
+
+ {{#isGson}}
+ /**
+ * Validates the JSON Element and throws an exception if issues found
+ *
+ * @param jsonElement JSON Element
+ * @throws IOException if the JSON Element is invalid with respect to {{classname}}
+ */
+ public static void validateJsonElement(JsonElement jsonElement) throws IOException {
+ List errorMessages = new ArrayList<>();
+ int matches = 0;
+
+ {{#composedSchemas}}
+ {{#anyOf}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ try {
+ // validate the JSON object to see if any exception is thrown
+ {{#isModel}}
+ {{#hasChildren}}
+ {{{dataType}}}.validateJsonElement(jsonElement);
+ {{/hasChildren}}
+ {{^hasChildren}}
+ {{#isArray}}
+ if (!jsonElement.isJsonArray()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a array type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isArray}}
+ {{^isArray}}
+ {{#isMap}}
+ if (!jsonElement.isJsonObject()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a object type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{^isMap}}
+ {{{dataType}}}.validateJsonElement(jsonElement);
+ {{/isMap}}
+ {{/isArray}}
+ {{/hasChildren}}
+ {{/isModel}}
+ {{#isPrimitiveType}}
+ {{#isArray}}
+ if (!jsonElement.isJsonArray()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a array type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isArray}}
+ {{^isArray}}
+ {{#isMap}}
+ if (!jsonElement.isJsonObject()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a object type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{^isMap}}
+ if (!jsonElement.isJsonPrimitive()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a primitive type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{/isArray}}
+ {{/isPrimitiveType}}
+ matches++;
+ } catch (Exception e) {
+ // deserialization failed, continue
+ errorMessages.add(String.format("Deserialization for {{{dataType}}} failed with `%s`.", e.getMessage()));
+ }
+
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/anyOf}}
+ {{/composedSchemas}}
+
+ if (matches == 0) {
+ throw new IOException(String.format("Failed deserialization for {{classname}}: no match found. %s", errorMessages));
+ }
+ }
+
+ public static class CustomTypeAdapterFactory implements TypeAdapterFactory {
+ @SuppressWarnings("unchecked")
+ @Override
+ public TypeAdapter create(Gson gson, TypeToken type) {
+ if (!{{classname}}.class.isAssignableFrom(type.getRawType())) {
+ return null; // this class only serializes '{{classname}}' and its subtypes
+ }
+ final TypeAdapter elementAdapter = gson.getAdapter(JsonElement.class);
+ {{#composedSchemas}}
+ {{#anyOf}}
+ {{^isArray}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ final TypeAdapter<{{{dataType}}}> adapter{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}} = gson.getDelegateAdapter(this, TypeToken.get({{{dataType}}}.class));
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/isArray}}
+ {{#isArray}}
+ final Type typeInstance{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}} = new TypeToken<{{{dataType}}}>(){}.getType();
+ final TypeAdapter<{{{dataType}}}> adapter{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}} = (TypeAdapter<{{{dataType}}}>) gson.getDelegateAdapter(this, TypeToken.get(typeInstance{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}}));
+ {{/isArray}}
+ {{/anyOf}}
+ {{/composedSchemas}}
+
+ return (TypeAdapter) new TypeAdapter<{{classname}}>() {
+ @Override
+ public void write(JsonWriter out, {{classname}} value) throws IOException {
+ if (value == null || value.getActualInstance() == null) {
+ elementAdapter.write(out, null);
+ return;
+ }
+
+ JsonElement element = null;
+ {{#composedSchemas}}
+ {{#anyOf}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ // check if the actual instance is of the type `{{{dataType}}}`
+ if (value.getActualInstance() instanceof {{#isArray}}List{{/isArray}}{{#isMap}}Map{{/isMap}}{{^isMap}}{{^isArray}}{{{dataType}}}{{/isArray}}{{/isMap}}) {
+ element = adapter{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}}.toJsonTree(({{{dataType}}})value.getActualInstance());
+ }
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/anyOf}}
+ {{/composedSchemas}}
+
+ if (element == null) {
+ throw new IOException("Failed to serialize as the type doesn't match anyOf schemas: {{#anyOf}}{{{.}}}{{^-last}}, {{/-last}}{{/anyOf}}");
+ }
+
+ {{#isAdditionalPropertiesTrue}}
+ if (element.isJsonObject()) {
+ writeUnconsumedProperties(value, element.getAsJsonObject(), gson);
+ }
+ {{/isAdditionalPropertiesTrue}}
+ elementAdapter.write(out, element);
+ }
+
+ @Override
+ public {{classname}} read(JsonReader in) throws IOException {
+ Object deserialized = null;
+ JsonElement jsonElement = elementAdapter.read(in);
+
+ {{#useOneOfDiscriminatorLookup}}
+ {{#discriminator}}
+ // non-object payloads can still match a non-object anyOf schema below
+ if (jsonElement.isJsonObject()) {
+ JsonObject jsonObject = jsonElement.getAsJsonObject();
+ JsonElement discriminatorElement = jsonObject.get("{{{propertyBaseName}}}");
+
+ // use discriminator value for faster anyOf lookup
+ {{classname}} new{{classname}} = new {{classname}}();
+ if (discriminatorElement == null || !discriminatorElement.isJsonPrimitive()) {
+ log.log(Level.WARNING, "Failed to lookup discriminator value for {{classname}} as `{{{propertyBaseName}}}` is missing or is not a primitive type in the payload.");
+ } else {
+ // look up the discriminator value in the field `{{{propertyBaseName}}}`
+ switch (discriminatorElement.getAsString()) {
+ {{#mappedModels}}
+ case "{{{mappingName}}}":
+ deserialized = adapter{{#sanitizeDataType}}{{{modelName}}}{{/sanitizeDataType}}.fromJsonTree(jsonObject);
+ new{{classname}}.setActualInstance(deserialized);
+ {{#isAdditionalPropertiesTrue}}
+ collectUnconsumedProperties(new{{classname}}, jsonElement, gson);
+ {{/isAdditionalPropertiesTrue}}
+ return new{{classname}};
+ {{/mappedModels}}
+ default:
+ log.log(Level.WARNING, String.format(java.util.Locale.ROOT, "Failed to lookup discriminator value `%s` for {{classname}}. Possible values:{{#mappedModels}} {{{mappingName}}}{{/mappedModels}}", discriminatorElement.getAsString()));
+ }
+ }
+ }
+
+ {{/discriminator}}
+ {{/useOneOfDiscriminatorLookup}}
+ ArrayList errorMessages = new ArrayList<>();
+ TypeAdapter actualAdapter = elementAdapter;
+
+ {{#composedSchemas}}
+ {{#anyOf}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ // deserialize {{{dataType}}}
+ try {
+ // validate the JSON object to see if any exception is thrown
+ {{#isModel}}
+ {{#hasChildren}}
+ {{{dataType}}}.validateJsonElement(jsonElement);
+ {{/hasChildren}}
+ {{^hasChildren}}
+ {{#isArray}}
+ if (!jsonElement.isJsonArray()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a array type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isArray}}
+ {{^isArray}}
+ {{#isMap}}
+ if (!jsonElement.isJsonObject()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a object type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{^isMap}}
+ {{{dataType}}}.validateJsonElement(jsonElement);
+ {{/isMap}}
+ {{/isArray}}
+ {{/hasChildren}}
+ {{/isModel}}
+ {{#isPrimitiveType}}
+ {{#isArray}}
+ if (!jsonElement.isJsonArray()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a array type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isArray}}
+ {{^isArray}}
+ {{#isMap}}
+ if (!jsonElement.isJsonObject()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a object type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{^isMap}}
+ if (!jsonElement.isJsonPrimitive()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a primitive type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{/isArray}}
+ {{/isPrimitiveType}}
+ {{classname}} ret = new {{classname}}();
+ ret.setActualInstance(adapter{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}}.fromJsonTree(jsonElement));
+ {{#isAdditionalPropertiesTrue}}
+ collectUnconsumedProperties(ret, jsonElement, gson);
+ {{/isAdditionalPropertiesTrue}}
+ return ret;
+ } catch (Exception e) {
+ // deserialization failed, continue
+ errorMessages.add(String.format("Deserialization for {{{dataType}}} failed with `%s`.", e.getMessage()));
+ log.log(Level.FINER, "Input data does not match schema '{{{dataType}}}'", e);
+ }
+
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/anyOf}}
+ {{/composedSchemas}}
+
+ throw new IOException(String.format("Failed deserialization for {{classname}}: no match found. %s", errorMessages));
+ }
+ };
+ }
+ }
+ {{/isGson}}
+
+ {{#isJackson}}
+ public static class {{classname}}Serializer extends StdSerializer<{{classname}}> {
+ public {{classname}}Serializer(Class<{{classname}}> t) {
+ super(t);
+ }
+
+ public {{classname}}Serializer() {
+ this(null);
+ }
+
+ @Override
+ public void serialize({{classname}} value, JsonGenerator jgen, {{^useJackson3}}SerializerProvider provider{{/useJackson3}}{{#useJackson3}}SerializationContext serializationContext{{/useJackson3}}) throws {{^useJackson3}}IOException{{/useJackson3}}{{#useJackson3}}JacksonException{{/useJackson3}} {
+ {{#isAdditionalPropertiesTrue}}
+ {{! @JsonAnyGetter is ignored on a class with a custom serializer, so the unconsumed
+ properties have to be merged into the child's tree by hand. }}
+ if (value.getActualInstance() != null && value.getAdditionalProperties() != null
+ && !value.getAdditionalProperties().isEmpty()) {
+ JsonNode node = JSON.getMapper().valueToTree(value.getActualInstance());
+ if (node != null && node.isObject()) {
+ {{jacksonPackage}}.databind.node.ObjectNode objectNode = ({{jacksonPackage}}.databind.node.ObjectNode) node;
+ for (Map.Entry entry : value.getAdditionalProperties().entrySet()) {
+ if (objectNode.has(entry.getKey())) {
+ // the child schema owns this property
+ continue;
+ }
+ objectNode.set(entry.getKey(), JSON.getMapper().valueToTree(entry.getValue()));
+ }
+ {{^useJackson3}}
+ jgen.writeTree(node);
+ {{/useJackson3}}
+ {{#useJackson3}}
+ serializationContext.writeValue(jgen, node);
+ {{/useJackson3}}
+ return;
+ }
+ }
+ {{/isAdditionalPropertiesTrue}}
+ {{^useJackson3}}
+ jgen.writeObject(value.getActualInstance());
+ {{/useJackson3}}
+ {{#useJackson3}}
+ serializationContext.writeValue(jgen, value.getActualInstance());
+ {{/useJackson3}}
+ }
+ }
+
+ public static class {{classname}}Deserializer extends StdDeserializer<{{classname}}> {
+ public {{classname}}Deserializer() {
+ this({{classname}}.class);
+ }
+
+ public {{classname}}Deserializer(Class vc) {
+ super(vc);
+ }
+
+ @Override
+ public {{classname}} deserialize(JsonParser jp, DeserializationContext ctxt) throws {{^useJackson3}}IOException{{/useJackson3}}{{#useJackson3}}JacksonException{{/useJackson3}} {
+ JsonNode tree = ctxt.readTree(jp);
+ Object deserialized = null;
+ {{#discriminator}}
+ Class cls = JSON.getClassForElement(tree, new {{classname}}().getClass());
+ if (cls != null) {
+ {{^useJackson3}}
+ deserialized = tree.traverse(jp.getCodec()).readValueAs(cls);
+ {{/useJackson3}}
+ {{#useJackson3}}
+ deserialized = ctxt.readTreeAsValue(tree, ctxt.constructType(cls));
+ {{/useJackson3}}
+ {{classname}} ret = new {{classname}}();
+ ret.setActualInstance(deserialized);
+ {{#isAdditionalPropertiesTrue}}
+ collectUnconsumedProperties(ret, tree);
+ {{/isAdditionalPropertiesTrue}}
+ return ret;
+ }
+ {{/discriminator}}
+ {{#composedSchemas.anyOf}}
+ // deserialize {{{dataType}}}
+ try {
+ {{^useJackson3}}
+ deserialized = tree.traverse(jp.getCodec()).readValueAs(new TypeReference<{{{dataType}}}>() {});
+ {{/useJackson3}}
+ {{#useJackson3}}
+ deserialized = ctxt.readTreeAsValue(tree, ctxt.getTypeFactory().constructType(new TypeReference<{{{dataType}}}>() {}));
+ {{/useJackson3}}
+ {{classname}} ret = new {{classname}}();
+ ret.setActualInstance(deserialized);
+ {{#isAdditionalPropertiesTrue}}
+ collectUnconsumedProperties(ret, tree);
+ {{/isAdditionalPropertiesTrue}}
+ return ret;
+ } catch (Exception e) {
+ // deserialization failed, continue
+ log.log(Level.FINER, "Input data does not match schema '{{{dataType}}}'", e);
+ }
+
+ {{/composedSchemas.anyOf}}
+ {{^useJackson3}}
+ throw new IOException(String.format(java.util.Locale.ROOT, "Failed deserialization for {{classname}}: no match found"));
+ {{/useJackson3}}
+ {{#useJackson3}}
+ throw DatabindException.from(jp, String.format(java.util.Locale.ROOT, "Failed deserialization for {{classname}}: no match found"));
+ {{/useJackson3}}
+ }
+
+ /**
+ * Handle deserialization of the 'null' value.
+ */
+ @Override
+ {{^useJackson3}}
+ public {{classname}} getNullValue(DeserializationContext ctxt) throws JsonMappingException {
+ {{/useJackson3}}
+ {{#useJackson3}}
+ public {{classname}} getNullValue(DeserializationContext ctxt) {
+ {{/useJackson3}}
+ {{#isNullable}}
+ return null;
+ {{/isNullable}}
+ {{^isNullable}}
+ {{^useJackson3}}
+ throw new JsonMappingException(ctxt.getParser(), "{{classname}} cannot be null");
+ {{/useJackson3}}
+ {{#useJackson3}}
+ throw DatabindException.from(ctxt.getParser(), "{{classname}} cannot be null");
+ {{/useJackson3}}
+ {{/isNullable}}
+ }
+ }
+ {{/isJackson}}
+
+ {{#isJsonb}}
+ public static class {{classname}}Serializer implements JsonbSerializer<{{classname}}> {
+ @Override
+ public void serialize({{classname}} obj, JsonGenerator generator, SerializationContext ctx) {
+ if (obj.getActualInstance() == null) {
+ generator.writeNull();
+ return;
+ }
+ {{#isAdditionalPropertiesTrue}}
+ if (obj.getAdditionalProperties() != null && !obj.getAdditionalProperties().isEmpty()) {
+ JsonObject childObject = toJsonObject(obj.getActualInstance());
+ if (childObject != null) {
+ jakarta.json.JsonObjectBuilder builder = jakarta.json.Json.createObjectBuilder(childObject);
+ for (Map.Entry entry : obj.getAdditionalProperties().entrySet()) {
+ if (childObject.containsKey(entry.getKey())) {
+ // the child schema owns this property
+ continue;
+ }
+ builder.add(entry.getKey(), toJsonValue(entry.getValue()));
+ }
+ ctx.serialize(builder.build(), generator);
+ return;
+ }
+ }
+ {{/isAdditionalPropertiesTrue}}
+ ctx.serialize(obj.getActualInstance(), generator);
+ }
+ }
+ {{#isAdditionalPropertiesTrue}}
+
+ /**
+ * Render a value through JSON-B and read it back as a JsonObject, or null if it is not an object.
+ */
+ private static JsonObject toJsonObject(Object value) {
+ try (jakarta.json.JsonReader reader = jakarta.json.Json.createReader(
+ new java.io.StringReader(JSON.getJsonb().toJson(value)))) {
+ jakarta.json.JsonStructure structure = reader.read();
+ return structure instanceof JsonObject ? (JsonObject) structure : null;
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ private static jakarta.json.JsonValue toJsonValue(Object value) {
+ if (value == null) {
+ return jakarta.json.JsonValue.NULL;
+ }
+ try (jakarta.json.JsonReader reader = jakarta.json.Json.createReader(
+ new java.io.StringReader(JSON.getJsonb().toJson(value)))) {
+ return reader.readValue();
+ }
+ }
+
+ /**
+ * Record the properties that the matched anyOf schema did not consume.
+ *
+ * The wrapper only owns what the selected child schema left behind. When that child accepts
+ * additional properties itself it absorbs them all and this records nothing, so a property is
+ * never stored — and therefore never written — twice.
+ */
+ private static void collectUnconsumedProperties({{classname}} instance, JsonObject jsonObject) {
+ if (jsonObject == null || instance.getActualInstance() == null) {
+ return;
+ }
+ JsonObject consumed = toJsonObject(instance.getActualInstance());
+ if (consumed == null) {
+ return;
+ }
+ for (Map.Entry entry : jsonObject.entrySet()) {
+ if (consumed.containsKey(entry.getKey())) {
+ continue;
+ }
+ instance.putAdditionalProperty(entry.getKey(), fromJsonValue(entry.getValue()));
+ }
+ }
+
+ private static Object fromJsonValue(jakarta.json.JsonValue value) {
+ switch (value.getValueType()) {
+ case STRING:
+ return ((jakarta.json.JsonString) value).getString();
+ case NUMBER:
+ return ((jakarta.json.JsonNumber) value).numberValue();
+ case TRUE:
+ return Boolean.TRUE;
+ case FALSE:
+ return Boolean.FALSE;
+ case NULL:
+ return null;
+ default:
+ return JSON.getJsonb().fromJson(value.toString(),
+ value.getValueType() == jakarta.json.JsonValue.ValueType.ARRAY
+ ? List.class : HashMap.class);
+ }
+ }
+ {{/isAdditionalPropertiesTrue}}
+
+ public static class {{classname}}Deserializer implements JsonbDeserializer<{{classname}}> {
+ @Override
+ public {{classname}} deserialize(JsonParser parser, DeserializationContext ctx, Type rt) {
+ JsonObject jsonObject = parser.getObject();
+ Object deserialized = null;
+ {{#useOneOfDiscriminatorLookup}}
+ {{#discriminator}}
+ if (jsonObject.containsKey("{{{propertyBaseName}}}")) {
+ String discriminatorValue = jsonObject.getString("{{{propertyBaseName}}}");
+ {{#mappedModels}}
+ if ("{{{mappingName}}}".equals(discriminatorValue)) {
+ deserialized = ctx.deserialize({{{modelName}}}.class, jakarta.json.Json.createParser(new java.io.StringReader(jsonObject.toString())));
+ {{classname}} new{{classname}} = new {{classname}}();
+ new{{classname}}.setActualInstance(deserialized);
+ {{#isAdditionalPropertiesTrue}}
+ collectUnconsumedProperties(new{{classname}}, jsonObject);
+ {{/isAdditionalPropertiesTrue}}
+ return new{{classname}};
+ }
+ {{/mappedModels}}
+ }
+ {{/discriminator}}
+ {{/useOneOfDiscriminatorLookup}}
+ int match = 0;
+ {{#composedSchemas.anyOf}}
+ // deserialize {{{dataType}}}
+ try {
+ deserialized = ctx.deserialize({{{baseType}}}.class, jakarta.json.Json.createParser(new java.io.StringReader(jsonObject.toString())));
+ match++;
+ {{classname}} ret = new {{classname}}();
+ ret.setActualInstance(deserialized);
+ {{#isAdditionalPropertiesTrue}}
+ collectUnconsumedProperties(ret, jsonObject);
+ {{/isAdditionalPropertiesTrue}}
+ return ret;
+ } catch (Exception e) {
+ // deserialization failed, continue
+ }
+ {{/composedSchemas.anyOf}}
+ if (match > 0) {
+ {{classname}} ret = new {{classname}}();
+ ret.setActualInstance(deserialized);
+ {{#isAdditionalPropertiesTrue}}
+ collectUnconsumedProperties(ret, jsonObject);
+ {{/isAdditionalPropertiesTrue}}
+ return ret;
+ }
+ throw new RuntimeException(String.format(java.util.Locale.ROOT, "Failed deserialization for {{classname}}: no match found"));
+ }
+ }
+ {{/isJsonb}}
+
+ // store a list of schema names defined in anyOf
+ public static final Map> schemas = new HashMap<>();
+
+ public {{classname}}() {
+ super("anyOf", {{#isNullable}}Boolean.TRUE{{/isNullable}}{{^isNullable}}Boolean.FALSE{{/isNullable}});
+ }
+
+ {{#composedSchemas.anyOf}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ public {{classname}}({{{dataType}}} o) {
+ super("anyOf", {{#isNullable}}Boolean.TRUE{{/isNullable}}{{^isNullable}}Boolean.FALSE{{/isNullable}});
+ setActualInstance(o);
+ }
+ {{/vendorExtensions.x-duplicated-data-type}}
+
+ {{/composedSchemas.anyOf}}
+ static {
+ {{#composedSchemas.anyOf}}
+ schemas.put("{{{dataType}}}", {{{baseType}}}.class);
+ {{/composedSchemas.anyOf}}
+ {{#isJackson}}
+ JSON.registerDescendants({{classname}}.class, Collections.unmodifiableMap(schemas));
+ {{#discriminator}}
+ // Initialize and register the discriminator mappings.
+ Map> mappings = new HashMap>();
+ {{#mappedModels}}
+ mappings.put("{{mappingName}}", {{modelName}}.class);
+ {{/mappedModels}}
+ mappings.put("{{name}}", {{classname}}.class);
+ JSON.registerDiscriminator({{classname}}.class, "{{propertyBaseName}}", mappings);
+ {{/discriminator}}
+ {{/isJackson}}
+ }
+
+ @Override
+ public Map> getSchemas() {
+ return {{classname}}.schemas;
+ }
+
+ /**
+ * Set the instance that matches the anyOf child schema, check
+ * the instance parameter is valid against the anyOf child schemas:
+ * {{#anyOf}}{{{.}}}{{^-last}}, {{/-last}}{{/anyOf}}
+ *
+ * It could be an instance of the 'anyOf' schemas.
+ * The anyOf child schemas may themselves be a composed schema (allOf, anyOf, anyOf).
+ */
+ @Override
+ public void setActualInstance(Object instance) {
+ {{#isNullable}}
+ if (instance == null) {
+ super.setActualInstance(instance);
+ return;
+ }
+
+ {{/isNullable}}
+ {{#composedSchemas.anyOf}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ if (JSON.isInstanceOf({{{baseType}}}.class, instance, new HashSet>())) {
+ super.setActualInstance(instance);
+ return;
+ }
+
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/composedSchemas.anyOf}}
+ throw new RuntimeException("Invalid instance type. Must be {{#anyOf}}{{{.}}}{{^-last}}, {{/-last}}{{/anyOf}}");
+ }
+
+ /**
+ * Get the actual instance, which can be the following:
+ * {{#anyOf}}{{{.}}}{{^-last}}, {{/-last}}{{/anyOf}}
+ *
+ * @return The actual instance ({{#anyOf}}{{{.}}}{{^-last}}, {{/-last}}{{/anyOf}})
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public Object getActualInstance() {
+ return super.getActualInstance();
+ }
+
+ {{#composedSchemas.anyOf}}
+ {{^vendorExtensions.x-duplicated-data-type-ignoring-erasure}}
+ /**
+ * Get the actual instance of `{{{dataType}}}`. If the actual instance is not `{{{dataType}}}`,
+ * the ClassCastException will be thrown.
+ *
+ * @return The actual instance of `{{{dataType}}}`
+ * @throws ClassCastException if the instance is not `{{{dataType}}}`
+ */
+ @SuppressWarnings("unchecked")
+ public {{{dataType}}} get{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}}() throws ClassCastException {
+ return ({{{dataType}}})super.getActualInstance();
+ }
+
+ {{/vendorExtensions.x-duplicated-data-type-ignoring-erasure}}
+ {{/composedSchemas.anyOf}}
+
+{{#supportUrlQuery}}
+
+ /**
+ * Convert the instance into URL query string.
+ *
+ * @return URL query string
+ */
+ public String toUrlQueryString() {
+ return toUrlQueryString(null);
+ }
+
+ /**
+ * Convert the instance into URL query string.
+ *
+ * @param prefix prefix of the query string
+ * @return URL query string
+ */
+ public String toUrlQueryString(String prefix) {
+ String suffix = "";
+ String containerSuffix = "";
+ String containerPrefix = "";
+ if (prefix == null) {
+ // style=form, explode=true, e.g. /pet?name=cat&type=manx
+ prefix = "";
+ } else {
+ // deepObject style e.g. /pet?id[name]=cat&id[type]=manx
+ prefix = prefix + "[";
+ suffix = "]";
+ containerSuffix = "]";
+ containerPrefix = "[";
+ }
+
+ StringJoiner joiner = new StringJoiner("&");
+
+ {{#composedSchemas.oneOf}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ if (getActualInstance() instanceof {{{dataType}}}) {
+ {{#isArray}}
+ {{#items.isPrimitiveType}}
+ {{#uniqueItems}}
+ if (getActualInstance() != null) {
+ int i = 0;
+ for ({{{items.dataType}}} _item : ({{{dataType}}})getActualInstance()) {
+ joiner.add(String.format(java.util.Locale.ROOT, "%s{{baseName}}%s%s=%s", prefix, suffix,
+ "".equals(suffix) ? "" : String.format(java.util.Locale.ROOT, "%s%d%s", containerPrefix, i, containerSuffix),
+ ApiClient.urlEncode(String.valueOf(_item))));
+ }
+ i++;
+ }
+ {{/uniqueItems}}
+ {{^uniqueItems}}
+ if (getActualInstance() != null) {
+ for (int i = 0; i < (({{{dataType}}})getActualInstance()).size(); i++) {
+ joiner.add(String.format(java.util.Locale.ROOT, "%s{{baseName}}%s%s=%s", prefix, suffix,
+ "".equals(suffix) ? "" : String.format(java.util.Locale.ROOT, "%s%d%s", containerPrefix, i, containerSuffix),
+ ApiClient.urlEncode(String.valueOf((({{{dataType}}})getActualInstance()).get(i)))));
+ }
+ }
+ {{/uniqueItems}}
+ {{/items.isPrimitiveType}}
+ {{^items.isPrimitiveType}}
+ {{#items.isModel}}
+ {{#uniqueItems}}
+ if (getActualInstance() != null) {
+ int i = 0;
+ for ({{{items.dataType}}} _item : ({{{dataType}}})getActualInstance()) {
+ if (_item != null) {
+ joiner.add(_item.toUrlQueryString(String.format(java.util.Locale.ROOT, "%s{{baseName}}%s%s", prefix, suffix,
+ "".equals(suffix) ? "" : String.format(java.util.Locale.ROOT, "%s%d%s", containerPrefix, i, containerSuffix))));
+ }
+ }
+ i++;
+ }
+ {{/uniqueItems}}
+ {{^uniqueItems}}
+ if (getActualInstance() != null) {
+ for (int i = 0; i < (({{{dataType}}})getActualInstance()).size(); i++) {
+ if ((({{{dataType}}})getActualInstance()).get(i) != null) {
+ joiner.add((({{{dataType}}})getActualInstance()).get(i).toUrlQueryString(String.format(java.util.Locale.ROOT, "%s{{baseName}}%s%s", prefix, suffix,
+ "".equals(suffix) ? "" : String.format(java.util.Locale.ROOT, "%s%d%s", containerPrefix, i, containerSuffix))));
+ }
+ }
+ }
+ {{/uniqueItems}}
+ {{/items.isModel}}
+ {{^items.isModel}}
+ {{#uniqueItems}}
+ if (getActualInstance() != null) {
+ int i = 0;
+ for ({{{items.dataType}}} _item : ({{{dataType}}})getActualInstance()) {
+ if (_item != null) {
+ joiner.add(String.format(java.util.Locale.ROOT, "%s{{baseName}}%s%s=%s", prefix, suffix,
+ "".equals(suffix) ? "" : String.format(java.util.Locale.ROOT, "%s%d%s", containerPrefix, i, containerSuffix),
+ ApiClient.urlEncode(String.valueOf(_item))));
+ }
+ i++;
+ }
+ }
+ {{/uniqueItems}}
+ {{^uniqueItems}}
+ if (getActualInstance() != null) {
+ for (int i = 0; i < (({{{dataType}}})getActualInstance()).size(); i++) {
+ if (getActualInstance().get(i) != null) {
+ joiner.add(String.format(java.util.Locale.ROOT, "%s{{baseName}}%s%s=%s", prefix, suffix,
+ "".equals(suffix) ? "" : String.format(java.util.Locale.ROOT, "%s%d%s", containerPrefix, i, containerSuffix),
+ ApiClient.urlEncode(String.valueOf((({{{dataType}}})getActualInstance()).get(i)))));
+ }
+ }
+ }
+ {{/uniqueItems}}
+ {{/items.isModel}}
+ {{/items.isPrimitiveType}}
+ {{/isArray}}
+ {{^isArray}}
+ {{#isMap}}
+ {{#items.isPrimitiveType}}
+ if (getActualInstance() != null) {
+ for (String _key : (({{{dataType}}})getActualInstance()).keySet()) {
+ joiner.add(String.format(java.util.Locale.ROOT, "%s{{baseName}}%s%s=%s", prefix, suffix,
+ "".equals(suffix) ? "" : String.format(java.util.Locale.ROOT, "%s%d%s", containerPrefix, _key, containerSuffix),
+ getActualInstance().get(_key), ApiClient.urlEncode(String.valueOf((({{{dataType}}})getActualInstance()).get(_key)))));
+ }
+ }
+ {{/items.isPrimitiveType}}
+ {{^items.isPrimitiveType}}
+ if (getActualInstance() != null) {
+ for (String _key : (({{{dataType}}})getActualInstance()).keySet()) {
+ if ((({{{dataType}}})getActualInstance()).get(_key) != null) {
+ joiner.add((({{{items.dataType}}})getActualInstance()).get(_key).toUrlQueryString(String.format(java.util.Locale.ROOT, "%s{{baseName}}%s%s", prefix, suffix,
+ "".equals(suffix) ? "" : String.format(java.util.Locale.ROOT, "%s%d%s", containerPrefix, _key, containerSuffix))));
+ }
+ }
+ }
+ {{/items.isPrimitiveType}}
+ {{/isMap}}
+ {{^isMap}}
+ {{#isPrimitiveType}}
+ if (getActualInstance() != null) {
+ joiner.add(String.format(java.util.Locale.ROOT, "%s{{{baseName}}}%s=%s", prefix, suffix, ApiClient.urlEncode(String.valueOf(getActualInstance()))));
+ }
+ {{/isPrimitiveType}}
+ {{^isPrimitiveType}}
+ {{#isModel}}
+ if (getActualInstance() != null) {
+ joiner.add((({{{dataType}}})getActualInstance()).toUrlQueryString(prefix + "{{{baseName}}}" + suffix));
+ }
+ {{/isModel}}
+ {{^isModel}}
+ if (getActualInstance() != null) {
+ joiner.add(String.format(java.util.Locale.ROOT, "%s{{{baseName}}}%s=%s", prefix, suffix, ApiClient.urlEncode(String.valueOf(getActualInstance()))));
+ }
+ {{/isModel}}
+ {{/isPrimitiveType}}
+ {{/isMap}}
+ {{/isArray}}
+ return joiner.toString();
+ }
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/composedSchemas.oneOf}}
+ return null;
+ }
+{{/supportUrlQuery}}
+
+{{#isGson}}
+ /**
+ * Create an instance of {{classname}} given an JSON string
+ *
+ * @param jsonString JSON string
+ * @return An instance of {{classname}}
+ * @throws IOException if the JSON string is invalid with respect to {{classname}}
+ */
+ public static {{{classname}}} fromJson(String jsonString) throws IOException {
+ return JSON.getGson().fromJson(jsonString, {{{classname}}}.class);
+ }
+
+ /**
+ * Convert an instance of {{classname}} to an JSON string
+ *
+ * @return JSON string
+ */
+ public String toJson() {
+ return JSON.getGson().toJson(this);
+ }
+{{/isGson}}
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/api.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/api.mustache
new file mode 100644
index 000000000000..29e9d152a37d
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/api.mustache
@@ -0,0 +1,626 @@
+{{>licenseInfo}}
+
+package {{package}};
+
+import {{invokerPackage}}.ApiCallback;
+import {{invokerPackage}}.ApiClient;
+import {{invokerPackage}}.ApiException;
+{{#dynamicOperations}}
+import {{invokerPackage}}.ApiOperation;
+{{/dynamicOperations}}
+import {{invokerPackage}}.ApiResponse;
+import {{invokerPackage}}.JSON;
+import {{invokerPackage}}.Configuration;
+import {{invokerPackage}}.Pair;
+import {{invokerPackage}}.ProgressRequestBody;
+import {{invokerPackage}}.ProgressResponseBody;
+{{#performBeanValidation}}
+import {{invokerPackage}}.BeanValidationException;
+{{/performBeanValidation}}
+
+{{#isGson}}
+import com.google.gson.reflect.TypeToken;
+{{/isGson}}
+{{#isJackson}}
+import {{jacksonPackage}}.core.type.TypeReference;
+{{/isJackson}}
+{{#dynamicOperations}}
+import io.swagger.v3.oas.models.Operation;
+import io.swagger.v3.oas.models.parameters.Parameter;
+{{/dynamicOperations}}
+
+import java.io.IOException;
+
+{{#useBeanValidation}}
+import {{javaxPackage}}.validation.constraints.*;
+import {{javaxPackage}}.validation.Valid;
+{{/useBeanValidation}}
+{{#performBeanValidation}}
+import {{javaxPackage}}.validation.ConstraintViolation;
+import {{javaxPackage}}.validation.Validation;
+import {{javaxPackage}}.validation.ValidatorFactory;
+import {{javaxPackage}}.validation.executable.ExecutableValidator;
+import java.util.Set;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+{{/performBeanValidation}}
+
+{{#imports}}import {{import}};
+{{/imports}}
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+{{#supportStreaming}}
+import java.io.InputStream;
+{{/supportStreaming}}
+
+{{#operations}}
+public class {{classname}} {
+ private ApiClient localVarApiClient;
+ private int localHostIndex;
+ private String localCustomBaseUrl;
+
+ public {{classname}}() {
+ this(Configuration.getDefaultApiClient());
+ }
+
+ public {{classname}}(ApiClient apiClient) {
+ this.localVarApiClient = apiClient;
+ }
+
+ public ApiClient getApiClient() {
+ return localVarApiClient;
+ }
+
+ public void setApiClient(ApiClient apiClient) {
+ this.localVarApiClient = apiClient;
+ }
+
+ public int getHostIndex() {
+ return localHostIndex;
+ }
+
+ public void setHostIndex(int hostIndex) {
+ this.localHostIndex = hostIndex;
+ }
+
+ public String getCustomBaseUrl() {
+ return localCustomBaseUrl;
+ }
+
+ public void setCustomBaseUrl(String customBaseUrl) {
+ this.localCustomBaseUrl = customBaseUrl;
+ }
+
+ {{#operation}}
+ {{^vendorExtensions.x-group-parameters}}/**
+ * Build call for {{operationId}}{{#allParams}}
+ * @param {{paramName}} {{description}}{{#required}} (required){{/required}}{{^required}} (optional{{^isContainer}}{{#defaultValue}}, default to {{.}}{{/defaultValue}}{{/isContainer}}){{/required}}{{/allParams}}
+ * @param _callback Callback for upload/download progress
+ * @return Call to execute
+ * @throws ApiException If fail to serialize the request body object
+ {{#responses.0}}
+ * @http.response.details
+
+ Response Details
+ | Status Code | Description | Response Headers |
+ {{#responses}}
+ | {{code}} | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+ {{/responses}}
+
+ {{/responses.0}}
+ {{#isDeprecated}}
+ * @deprecated
+ {{/isDeprecated}}
+ {{#externalDocs}}
+ * {{description}}
+ * @see {{summary}} Documentation
+ {{/externalDocs}}
+ */
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ public{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}private{{/vendorExtensions.x-group-parameters}} okhttp3.Call {{operationId}}Call({{#allParams}}{{>nullableArgument}} {{paramName}}, {{/allParams}}final ApiCallback _callback) throws ApiException {
+ String basePath = null;
+ // Operation Servers
+ String[] localBasePaths = new String[] { {{#servers}}"{{{url}}}"{{^-last}}, {{/-last}}{{/servers}} };
+
+ // Determine Base Path to Use
+ if (localCustomBaseUrl != null){
+ basePath = localCustomBaseUrl;
+ } else if ( localBasePaths.length > 0 ) {
+ basePath = localBasePaths[localHostIndex];
+ } else {
+ basePath = null;
+ }
+
+ Object localVarPostBody = {{#bodyParam}}{{paramName}}{{/bodyParam}}{{^bodyParam}}null{{/bodyParam}};
+
+ // create path and map variables
+ {{^dynamicOperations}}
+ String localVarPath = "{{{path}}}"{{#pathParams}}
+ .replace("{" + "{{baseName}}" + "}", localVarApiClient.escapeString({{#collectionFormat}}localVarApiClient.collectionPathParameterToString("{{{collectionFormat}}}", {{{paramName}}}){{/collectionFormat}}{{^collectionFormat}}{{{paramName}}}.toString(){{/collectionFormat}})){{/pathParams}};
+ {{/dynamicOperations}}
+ {{#dynamicOperations}}
+ ApiOperation apiOperation = localVarApiClient.getOperationLookupMap().get("{{{operationId}}}");
+ if (apiOperation == null) {
+ throw new ApiException("Operation not found in OAS");
+ }
+ Operation operation = apiOperation.getOperation();
+ String localVarPath = apiOperation.getPath();
+ Map paramMap = new HashMap<>();
+ {{#allParams}}
+ {{^isFormParam}}
+ {{^isBodyParam}}
+ paramMap.put("{{baseName}}", {{paramName}});
+ {{/isBodyParam}}
+ {{/isFormParam}}
+ {{/allParams}}
+ {{/dynamicOperations}}
+
+ List localVarQueryParams = new ArrayList();
+ List localVarCollectionQueryParams = new ArrayList();
+ Map localVarHeaderParams = new HashMap();
+ Map localVarCookieParams = new HashMap();
+ Map localVarFormParams = new HashMap();
+
+ {{#formParams}}
+ if ({{paramName}} != null) {
+ localVarFormParams.put("{{baseName}}", {{paramName}});
+ }
+
+ {{/formParams}}
+ {{^dynamicOperations}}
+ {{#queryParams}}
+ if ({{paramName}} != null) {
+ {{#isFreeFormObject}}localVarQueryParams.addAll(localVarApiClient.freeFormParameterToPairs({{paramName}}));{{/isFreeFormObject}}{{^isFreeFormObject}}{{#collectionFormat}}localVarCollectionQueryParams.addAll(localVarApiClient.parameterToPairs("{{{.}}}", {{/collectionFormat}}{{^collectionFormat}}localVarQueryParams.addAll(localVarApiClient.parameterToPair({{/collectionFormat}}"{{baseName}}", {{paramName}}));{{/isFreeFormObject}}
+ }
+
+ {{/queryParams}}
+ {{#constantParams}}
+ {{#isQueryParam}}
+ // Set client side default value of Query Param "{{baseName}}".
+ localVarCollectionQueryParams.add(new Pair("{{baseName}}", {{#_enum}}"{{{.}}}"{{/_enum}}));
+
+ {{/isQueryParam}}
+ {{/constantParams}}
+ {{#constantParams}}
+ {{#isHeaderParam}}
+ // Set client side default value of Header Param "{{baseName}}".
+ localVarHeaderParams.put("{{baseName}}", {{#_enum}}"{{{.}}}"{{/_enum}});
+
+ {{/isHeaderParam}}
+ {{/constantParams}}
+ {{#cookieParams}}
+ if ({{paramName}} != null) {
+ localVarCookieParams.put("{{baseName}}", localVarApiClient.parameterToString({{paramName}}));
+ }
+
+ {{/cookieParams}}
+ {{#constantParams}}
+ {{#isCookieParam}}
+ // Set client side default value of Cookie Param "{{baseName}}".
+ localVarCookieParams.put("{{baseName}}", {{#_enum}}"{{{.}}}"{{/_enum}});
+
+ {{/isCookieParam}}
+ {{/constantParams}}
+ {{/dynamicOperations}}
+ {{#dynamicOperations}}
+ localVarPath = localVarApiClient.fillParametersFromOperation(operation, paramMap, localVarPath, localVarQueryParams, localVarCollectionQueryParams, localVarHeaderParams, localVarCookieParams);
+
+ {{/dynamicOperations}}
+ final String[] localVarAccepts = {
+ {{#produces}}
+ "{{{mediaType}}}"{{^-last}},{{/-last}}
+ {{/produces}}
+ };
+ final String localVarAccept = localVarApiClient.selectHeaderAccept(localVarAccepts);
+ if (localVarAccept != null) {
+ localVarHeaderParams.put("Accept", localVarAccept);
+ }
+
+ final String[] localVarContentTypes = {
+ {{#consumes}}
+ "{{{mediaType}}}"{{^-last}},{{/-last}}
+ {{/consumes}}
+ };
+ final String localVarContentType = localVarApiClient.selectHeaderContentType(localVarContentTypes);
+ if (localVarContentType != null) {
+ localVarHeaderParams.put("Content-Type", localVarContentType);
+ }
+ {{^dynamicOperations}}
+ {{#headerParams}}
+
+ if ({{paramName}} != null) {
+ localVarHeaderParams.put("{{baseName}}", localVarApiClient.parameterToString({{paramName}}));
+ }
+
+ {{/headerParams}}
+ {{/dynamicOperations}}
+
+ String[] localVarAuthNames = new String[] { {{#authMethods}}"{{name}}"{{^-last}}, {{/-last}}{{#-last}}{{#withAWSV4Signature}}, {{/withAWSV4Signature}}{{/-last}}{{/authMethods}}{{#withAWSV4Signature}}"AWS4Auth"{{/withAWSV4Signature}} };
+ return localVarApiClient.buildCall(basePath, localVarPath, {{^dynamicOperations}}"{{httpMethod}}"{{/dynamicOperations}}{{#dynamicOperations}}apiOperation.getMethod(){{/dynamicOperations}}, localVarQueryParams, localVarCollectionQueryParams, localVarPostBody, localVarHeaderParams, localVarCookieParams, localVarFormParams, localVarAuthNames, _callback);
+ }
+
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ @SuppressWarnings("rawtypes")
+ private okhttp3.Call {{operationId}}ValidateBeforeCall({{#allParams}}{{>nullableArgument}} {{paramName}}, {{/allParams}}final ApiCallback _callback) throws ApiException {
+ {{^performBeanValidation}}
+ {{#allParams}}
+ {{#required}}
+ // verify the required parameter '{{paramName}}' is set
+ if ({{paramName}} == null) {
+ throw new ApiException("Missing the required parameter '{{paramName}}' when calling {{operationId}}(Async)");
+ }
+
+ {{/required}}
+ {{/allParams}}
+ return {{operationId}}Call({{#allParams}}{{paramName}}, {{/allParams}}_callback);
+
+ {{/performBeanValidation}}
+ {{#performBeanValidation}}
+ try {
+ ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
+ ExecutableValidator executableValidator = factory.getValidator().forExecutables();
+
+ Object[] parameterValues = { {{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}} };
+ Method method = this.getClass().getMethod("{{operationId}}WithHttpInfo"{{#allParams}}, {{#isArray}}java.util.List{{/isArray}}{{#isMap}}java.util.Map{{/isMap}}{{^isArray}}{{^isMap}}{{>nullable_var_annotations}} {{{dataType}}}{{/isMap}}{{/isArray}}.class{{/allParams}});
+ Set> violations = executableValidator.validateParameters(this, method,
+ parameterValues);
+
+ if (violations.size() == 0) {
+ return {{operationId}}Call({{#allParams}}{{paramName}}, {{/allParams}}_callback);
+ } else {
+ throw new BeanValidationException((Set) violations);
+ }
+ } catch (NoSuchMethodException e) {
+ e.printStackTrace();
+ throw new ApiException(e.getMessage());
+ } catch (SecurityException e) {
+ e.printStackTrace();
+ throw new ApiException(e.getMessage());
+ }
+ {{/performBeanValidation}}
+ }
+
+ {{^vendorExtensions.x-group-parameters}}
+ /**
+ * {{summary}}
+ * {{notes}}{{#allParams}}
+ * @param {{paramName}} {{description}}{{#required}} (required){{/required}}{{^required}} (optional{{^isContainer}}{{#defaultValue}}, default to {{.}}{{/defaultValue}}{{/isContainer}}){{/required}}{{/allParams}}{{#returnType}}
+ * @return {{.}}{{/returnType}}
+ * @throws ApiException If fail to call the API, e.g. server error or cannot deserialize the response body
+ {{#responses.0}}
+ * @http.response.details
+
+ Response Details
+ | Status Code | Description | Response Headers |
+ {{#responses}}
+ | {{code}} | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+ {{/responses}}
+
+ {{/responses.0}}
+ {{#isDeprecated}}
+ * @deprecated
+ {{/isDeprecated}}
+ {{#externalDocs}}
+ * {{description}}
+ * @see {{summary}} Documentation
+ {{/externalDocs}}
+ */
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ {{#vendorExtensions.x-streaming}}
+ public {{#returnType}}InputStream {{/returnType}}{{^returnType}}void {{/returnType}}{{operationId}}({{#allParams}}{{>nullableArgument}} {{paramName}}{{^-last}}, {{/-last}}{{/allParams}}) throws ApiException {
+ {{#returnType}}InputStream localVarResp = {{/returnType}}{{operationId}}WithHttpInfo({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}});{{#returnType}}
+ return localVarResp;{{/returnType}}
+ }
+ {{/vendorExtensions.x-streaming}}
+ {{^vendorExtensions.x-streaming}}
+ public {{#returnType}}{{{.}}} {{/returnType}}{{^returnType}}void {{/returnType}}{{operationId}}({{#allParams}}{{>nullableArgument}} {{paramName}}{{^-last}}, {{/-last}}{{/allParams}}) throws ApiException {
+ {{#returnType}}ApiResponse<{{{.}}}> localVarResp = {{/returnType}}{{operationId}}WithHttpInfo({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}});{{#returnType}}
+ return localVarResp.getData();{{/returnType}}
+ }
+ {{/vendorExtensions.x-streaming}}
+ {{/vendorExtensions.x-group-parameters}}
+
+ {{^vendorExtensions.x-group-parameters}}/**
+ * {{summary}}
+ * {{notes}}{{#allParams}}
+ * @param {{paramName}} {{description}}{{#required}} (required){{/required}}{{^required}} (optional{{^isContainer}}{{#defaultValue}}, default to {{.}}{{/defaultValue}}{{/isContainer}}){{/required}}{{/allParams}}
+ * @return ApiResponse<{{returnType}}{{^returnType}}Void{{/returnType}}>
+ * @throws ApiException If fail to call the API, e.g. server error or cannot deserialize the response body
+ {{#responses.0}}
+ * @http.response.details
+
+ Response Details
+ | Status Code | Description | Response Headers |
+ {{#responses}}
+ | {{code}} | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+ {{/responses}}
+
+ {{/responses.0}}
+ {{#isDeprecated}}
+ * @deprecated
+ {{/isDeprecated}}
+ {{#externalDocs}}
+ * {{description}}
+ * @see {{summary}} Documentation
+ {{/externalDocs}}
+ */
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ public{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}private{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-streaming}} InputStream {{operationId}}WithHttpInfo({{#allParams}}{{#useBeanValidation}}{{>beanValidationQueryParams}}{{/useBeanValidation}}{{>nullable_var_annotations}} {{{dataType}}} {{paramName}}{{^-last}}, {{/-last}}{{/allParams}}) throws ApiException {
+ okhttp3.Call localVarCall = {{operationId}}ValidateBeforeCall({{#allParams}}{{paramName}}, {{/allParams}}null);
+ {{#returnType}}
+ {{#errorObjectType}}
+ try {
+ {{#isGson}}Type localVarReturnType = new TypeToken<{{{returnType}}}>(){}.getType();{{/isGson}}
+ {{#isJackson}}Type localVarReturnType = new TypeReference<{{{returnType}}}>(){}.getType();{{/isJackson}}
+ {{#isJsonb}}Type localVarReturnType = new JSON.GenericType<{{{returnType}}}>(){}.getType();{{/isJsonb}}
+ return localVarApiClient.executeStream(localVarCall, localVarReturnType);
+ } catch (ApiException e) {
+ {{#isGson}}e.setErrorObject(localVarApiClient.getJSON().getGson().fromJson(e.getResponseBody(), new TypeToken<{{{errorObjectType}}}>(){}.getType()));{{/isGson}}
+ {{#isJsonb}}e.setErrorObject(localVarApiClient.getJSON().deserialize(e.getResponseBody(), new JSON.GenericType<{{{errorObjectType}}}>(){}.getType()));{{/isJsonb}}
+ throw e;
+ }
+ {{/errorObjectType}}
+ {{^errorObjectType}}
+ {{#isGson}}Type localVarReturnType = new TypeToken<{{{returnType}}}>(){}.getType();{{/isGson}}
+ {{#isJackson}}Type localVarReturnType = new TypeReference<{{{returnType}}}>(){}.getType();{{/isJackson}}
+ {{#isJsonb}}Type localVarReturnType = new JSON.GenericType<{{{returnType}}}>(){}.getType();{{/isJsonb}}
+ return localVarApiClient.executeStream(localVarCall, localVarReturnType);
+ {{/errorObjectType}}
+ {{/returnType}}
+ }
+ {{/vendorExtensions.x-streaming}}{{^vendorExtensions.x-streaming}} ApiResponse<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}Void{{/returnType}}> {{operationId}}WithHttpInfo({{#allParams}}{{#useBeanValidation}}{{>beanValidationQueryParams}}{{/useBeanValidation}}{{>nullableArgument}} {{paramName}}{{^-last}}, {{/-last}}{{/allParams}}) throws ApiException {
+ okhttp3.Call localVarCall = {{operationId}}ValidateBeforeCall({{#allParams}}{{paramName}}, {{/allParams}}null);
+ {{^returnType}}
+ return localVarApiClient.execute(localVarCall);
+ {{/returnType}}
+ {{#returnType}}
+ {{#errorObjectType}}
+ try {
+ {{#isGson}}Type localVarReturnType = new TypeToken<{{{returnType}}}>(){}.getType();{{/isGson}}
+ {{#isJackson}}Type localVarReturnType = new TypeReference<{{{returnType}}}>(){}.getType();{{/isJackson}}
+ {{#isJsonb}}Type localVarReturnType = new JSON.GenericType<{{{returnType}}}>(){}.getType();{{/isJsonb}}
+ return localVarApiClient.execute(localVarCall, localVarReturnType);
+ } catch (ApiException e) {
+ {{#isGson}}e.setErrorObject(localVarApiClient.getJSON().getGson().fromJson(e.getResponseBody(), new TypeToken<{{{errorObjectType}}}>(){}.getType()));{{/isGson}}
+ {{#isJsonb}}e.setErrorObject(localVarApiClient.getJSON().deserialize(e.getResponseBody(), new JSON.GenericType<{{{errorObjectType}}}>(){}.getType()));{{/isJsonb}}
+ throw e;
+ }
+ {{/errorObjectType}}
+ {{^errorObjectType}}
+ {{#isGson}}Type localVarReturnType = new TypeToken<{{{returnType}}}>(){}.getType();{{/isGson}}
+ {{#isJackson}}Type localVarReturnType = new TypeReference<{{{returnType}}}>(){}.getType();{{/isJackson}}
+ {{#isJsonb}}Type localVarReturnType = new JSON.GenericType<{{{returnType}}}>(){}.getType();{{/isJsonb}}
+ return localVarApiClient.execute(localVarCall, localVarReturnType);
+ {{/errorObjectType}}
+ {{/returnType}}
+ }
+ {{/vendorExtensions.x-streaming}}
+
+ {{^vendorExtensions.x-group-parameters}}/**
+ * {{summary}} (asynchronously)
+ * {{notes}}{{#allParams}}
+ * @param {{paramName}} {{description}}{{#required}} (required){{/required}}{{^required}} (optional{{^isContainer}}{{#defaultValue}}, default to {{.}}{{/defaultValue}}{{/isContainer}}){{/required}}{{/allParams}}
+ * @param _callback The callback to be executed when the API call finishes
+ * @return The request call
+ * @throws ApiException If fail to process the API call, e.g. serializing the request body object
+ {{#responses.0}}
+ * @http.response.details
+
+ Response Details
+ | Status Code | Description | Response Headers |
+ {{#responses}}
+ | {{code}} | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+ {{/responses}}
+
+ {{/responses.0}}
+ {{#isDeprecated}}
+ * @deprecated
+ {{/isDeprecated}}
+ {{#externalDocs}}
+ * {{description}}
+ * @see {{summary}} Documentation
+ {{/externalDocs}}
+ */
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ public{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}private{{/vendorExtensions.x-group-parameters}} okhttp3.Call {{operationId}}Async({{#allParams}}{{>nullableArgument}} {{paramName}}, {{/allParams}}final ApiCallback<{{{returnType}}}{{^returnType}}Void{{/returnType}}> _callback) throws ApiException {
+
+ okhttp3.Call localVarCall = {{operationId}}ValidateBeforeCall({{#allParams}}{{paramName}}, {{/allParams}}_callback);
+ {{#returnType}}{{#isGson}}Type localVarReturnType = new TypeToken<{{{returnType}}}>(){}.getType();{{/isGson}}{{#isJackson}}Type localVarReturnType = new TypeReference<{{{returnType}}}>(){}.getType();{{/isJackson}}{{#isJsonb}}Type localVarReturnType = new JSON.GenericType<{{{returnType}}}>(){}.getType();{{/isJsonb}}
+ localVarApiClient.executeAsync(localVarCall, localVarReturnType, _callback);{{/returnType}}{{^returnType}}localVarApiClient.executeAsync(localVarCall, _callback);{{/returnType}}
+ return localVarCall;
+ }
+ {{#vendorExtensions.x-group-parameters}}
+
+ public class API{{operationId}}Request {
+ {{#requiredParams}}
+ {{>nullable_var_annotations}}{{! prevent indent}}
+ private final {{#lambda.jSpecifyDatatype}}{{{dataType}}}{{/lambda.jSpecifyDatatype}} {{paramName}};
+ {{/requiredParams}}
+ {{#optionalParams}}
+ {{>nullable_var_annotations}}{{! prevent indent}}
+ private {{#lambda.jSpecifyDatatype}}{{{dataType}}}{{/lambda.jSpecifyDatatype}} {{paramName}};
+ {{/optionalParams}}
+
+ private API{{operationId}}Request({{#requiredParams}}{{>nullableArgument}} {{paramName}}{{^-last}}, {{/-last}}{{/requiredParams}}) {
+ {{#requiredParams}}
+ this.{{paramName}} = {{paramName}};
+ {{/requiredParams}}
+ }
+
+ {{#optionalParams}}
+ /**
+ * Set {{paramName}}
+ * @param {{paramName}} {{description}} (optional{{^isContainer}}{{#defaultValue}}, default to {{.}}{{/defaultValue}}{{/isContainer}})
+ * @return API{{operationId}}Request
+ */
+ public API{{operationId}}Request {{paramName}}({{>nullableArgument}} {{paramName}}) {
+ this.{{paramName}} = {{paramName}};
+ return this;
+ }
+
+ {{/optionalParams}}
+ /**
+ * Build call for {{operationId}}
+ * @param _callback ApiCallback API callback
+ * @return Call to execute
+ * @throws ApiException If fail to serialize the request body object
+ {{#responses.0}}
+ * @http.response.details
+
+ Response Details
+ | Status Code | Description | Response Headers |
+ {{#responses}}
+ | {{code}} | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+ {{/responses}}
+
+ {{/responses.0}}
+ {{#isDeprecated}}
+ * @deprecated
+ {{/isDeprecated}}
+ */
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ public okhttp3.Call buildCall(final ApiCallback _callback) throws ApiException {
+ return {{operationId}}Call({{#allParams}}{{paramName}}, {{/allParams}}_callback);
+ }
+
+ /**
+ * Execute {{operationId}} request{{#returnType}}
+ * @return {{.}}{{/returnType}}
+ * @throws ApiException If fail to call the API, e.g. server error or cannot deserialize the response body
+ {{#responses.0}}
+ * @http.response.details
+
+ Response Details
+ | Status Code | Description | Response Headers |
+ {{#responses}}
+ | {{code}} | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+ {{/responses}}
+
+ {{/responses.0}}
+ {{#isDeprecated}}
+ * @deprecated
+ {{/isDeprecated}}
+ */
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ {{^vendorExtensions.x-streaming}}
+ public {{{returnType}}}{{^returnType}}void{{/returnType}} execute() throws ApiException {
+ {{#returnType}}ApiResponse<{{{.}}}> localVarResp = {{/returnType}}{{operationId}}WithHttpInfo({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}});{{#returnType}}
+ return localVarResp.getData();{{/returnType}}
+ }
+ {{/vendorExtensions.x-streaming}}
+ {{#vendorExtensions.x-streaming}}
+ public InputStream execute() throws ApiException {
+ return {{operationId}}WithHttpInfo({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}});
+ }
+ {{/vendorExtensions.x-streaming}}
+
+ /**
+ * Execute {{operationId}} request with HTTP info returned
+ * @return ApiResponse<{{returnType}}{{^returnType}}Void{{/returnType}}>
+ * @throws ApiException If fail to call the API, e.g. server error or cannot deserialize the response body
+ {{#responses.0}}
+ * @http.response.details
+
+ Response Details
+ | Status Code | Description | Response Headers |
+ {{#responses}}
+ | {{code}} | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+ {{/responses}}
+
+ {{/responses.0}}
+ {{#isDeprecated}}
+ * @deprecated
+ {{/isDeprecated}}
+ */
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ {{^vendorExtensions.x-streaming}}
+ public ApiResponse<{{{returnType}}}{{^returnType}}Void{{/returnType}}> executeWithHttpInfo() throws ApiException {
+ return {{operationId}}WithHttpInfo({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}});
+ }
+ {{/vendorExtensions.x-streaming}}
+ {{#vendorExtensions.x-streaming}}
+ public InputStream executeWithHttpInfo() throws ApiException {
+ return {{operationId}}WithHttpInfo({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}});
+ }
+ {{/vendorExtensions.x-streaming}}
+
+ /**
+ * Execute {{operationId}} request (asynchronously)
+ * @param _callback The callback to be executed when the API call finishes
+ * @return The request call
+ * @throws ApiException If fail to process the API call, e.g. serializing the request body object
+ {{#responses.0}}
+ * @http.response.details
+
+ Response Details
+ | Status Code | Description | Response Headers |
+ {{#responses}}
+ | {{code}} | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+ {{/responses}}
+
+ {{/responses.0}}
+ {{#isDeprecated}}
+ * @deprecated
+ {{/isDeprecated}}
+ */
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ public okhttp3.Call executeAsync(final ApiCallback<{{{returnType}}}{{^returnType}}Void{{/returnType}}> _callback) throws ApiException {
+ return {{operationId}}Async({{#allParams}}{{paramName}}, {{/allParams}}_callback);
+ }
+ }
+
+ /**
+ * {{summary}}
+ * {{notes}}{{#requiredParams}}
+ * @param {{paramName}} {{description}} (required){{/requiredParams}}
+ * @return API{{operationId}}Request
+ {{#responses.0}}
+ * @http.response.details
+
+ Response Details
+ | Status Code | Description | Response Headers |
+ {{#responses}}
+ | {{code}} | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+ {{/responses}}
+
+ {{/responses.0}}
+ {{#isDeprecated}}
+ * @deprecated
+ {{/isDeprecated}}
+ {{#externalDocs}}
+ * {{description}}
+ * @see {{summary}} Documentation
+ {{/externalDocs}}
+ */
+ {{#isDeprecated}}
+ @Deprecated
+ {{/isDeprecated}}
+ public API{{operationId}}Request {{operationId}}({{#requiredParams}}{{>nullable_var_annotations}} {{{dataType}}} {{paramName}}{{^-last}}, {{/-last}}{{/requiredParams}}) {
+ return new API{{operationId}}Request({{#requiredParams}}{{paramName}}{{^-last}}, {{/-last}}{{/requiredParams}});
+ }
+ {{/vendorExtensions.x-group-parameters}}
+ {{/operation}}
+}
+{{/operations}}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/apiException.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/apiException.mustache
new file mode 100644
index 000000000000..96283bc054d3
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/apiException.mustache
@@ -0,0 +1,196 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}};
+
+import java.util.Map;
+import java.util.List;
+{{#caseInsensitiveResponseHeaders}}
+import java.util.Map.Entry;
+import java.util.TreeMap;
+{{/caseInsensitiveResponseHeaders}}
+
+
+/**
+ * ApiException class.
+ */
+@SuppressWarnings("serial")
+{{>generatedAnnotation}}
+
+public class ApiException extends{{#useRuntimeException}} RuntimeException {{/useRuntimeException}}{{^useRuntimeException}} Exception {{/useRuntimeException}}{
+ private static final long serialVersionUID = 1L;
+
+ private int code = 0;
+ private Map> responseHeaders = null;
+ private String responseBody = null;
+ {{#errorObjectType}}
+ private {{{errorObjectType}}} errorObject = null;
+ {{/errorObjectType}}
+
+ /**
+ * Constructor for ApiException.
+ */
+ public ApiException() {}
+
+ /**
+ * Constructor for ApiException.
+ *
+ * @param throwable a {@link java.lang.Throwable} object
+ */
+ public ApiException(Throwable throwable) {
+ super(throwable);
+ }
+
+ /**
+ * Constructor for ApiException.
+ *
+ * @param message the error message
+ */
+ public ApiException(String message) {
+ super(message);
+ }
+
+ /**
+ * Constructor for ApiException.
+ *
+ * @param message the error message
+ * @param throwable a {@link java.lang.Throwable} object
+ * @param code HTTP status code
+ * @param responseHeaders a {@link java.util.Map} of HTTP response headers
+ * @param responseBody the response body
+ */
+ public ApiException(String message, Throwable throwable, int code, Map> responseHeaders, String responseBody) {
+ super(message, throwable);
+ this.code = code;
+ {{#caseInsensitiveResponseHeaders}}
+ Map> headers = new TreeMap>(String.CASE_INSENSITIVE_ORDER);
+ for(Entry> entry : responseHeaders.entrySet()){
+ headers.put(entry.getKey().toLowerCase(), entry.getValue());
+ }
+ {{/caseInsensitiveResponseHeaders}}
+ this.responseHeaders = {{#caseInsensitiveResponseHeaders}}headers{{/caseInsensitiveResponseHeaders}}{{^caseInsensitiveResponseHeaders}}responseHeaders{{/caseInsensitiveResponseHeaders}};
+ this.responseBody = responseBody;
+ }
+
+ /**
+ * Constructor for ApiException.
+ *
+ * @param message the error message
+ * @param code HTTP status code
+ * @param responseHeaders a {@link java.util.Map} of HTTP response headers
+ * @param responseBody the response body
+ */
+ public ApiException(String message, int code, Map> responseHeaders, String responseBody) {
+ this(message, (Throwable) null, code, responseHeaders, responseBody);
+ }
+
+ /**
+ * Constructor for ApiException.
+ *
+ * @param message the error message
+ * @param throwable a {@link java.lang.Throwable} object
+ * @param code HTTP status code
+ * @param responseHeaders a {@link java.util.Map} of HTTP response headers
+ */
+ public ApiException(String message, Throwable throwable, int code, Map> responseHeaders) {
+ this(message, throwable, code, responseHeaders, null);
+ }
+
+ /**
+ * Constructor for ApiException.
+ *
+ * @param code HTTP status code
+ * @param responseHeaders a {@link java.util.Map} of HTTP response headers
+ * @param responseBody the response body
+ */
+ public ApiException(int code, Map> responseHeaders, String responseBody) {
+ this("Response Code: " + code + " Response Body: " + responseBody, (Throwable) null, code, responseHeaders, responseBody);
+ }
+
+ /**
+ * Constructor for ApiException.
+ *
+ * @param code HTTP status code
+ * @param message a {@link java.lang.String} object
+ */
+ public ApiException(int code, String message) {
+ super(message);
+ this.code = code;
+ }
+
+ /**
+ * Constructor for ApiException.
+ *
+ * @param code HTTP status code
+ * @param message the error message
+ * @param responseHeaders a {@link java.util.Map} of HTTP response headers
+ * @param responseBody the response body
+ */
+ public ApiException(int code, String message, Map> responseHeaders, String responseBody) {
+ this(code, message);
+ {{#caseInsensitiveResponseHeaders}}
+ Map> headers = new TreeMap>(String.CASE_INSENSITIVE_ORDER);
+ for(Entry> entry : responseHeaders.entrySet()){
+ headers.put(entry.getKey().toLowerCase(), entry.getValue());
+ }
+ {{/caseInsensitiveResponseHeaders}}
+ this.responseHeaders = {{#caseInsensitiveResponseHeaders}}headers{{/caseInsensitiveResponseHeaders}}{{^caseInsensitiveResponseHeaders}}responseHeaders{{/caseInsensitiveResponseHeaders}};
+ 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 Map> getResponseHeaders() {
+ return responseHeaders;
+ }
+
+ /**
+ * Get the HTTP response body.
+ *
+ * @return Response body in the form of string
+ */
+ public String getResponseBody() {
+ return responseBody;
+ }
+
+ /**
+ * Get the exception message including HTTP response data.
+ *
+ * @return The exception message
+ */
+ public String getMessage() {
+ return String.format(java.util.Locale.ROOT, "Message: %s%nHTTP response code: %s%nHTTP response body: %s%nHTTP response headers: %s",
+ super.getMessage(), this.getCode(), this.getResponseBody(), this.getResponseHeaders());
+ }
+ {{#errorObjectType}}
+
+ /**
+ * Get the error object.
+ *
+ * @return Error object
+ */
+ public {{{errorObjectType}}} getErrorObject() {
+ return errorObject;
+ }
+
+ /**
+ * Get the error object.
+ *
+ * @param errorObject Error object
+ */
+ public void setErrorObject({{{errorObjectType}}} errorObject) {
+ this.errorObject = errorObject;
+ }
+ {{/errorObjectType}}
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/api_doc.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/api_doc.mustache
new file mode 100644
index 000000000000..dea75bd2b98e
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/api_doc.mustache
@@ -0,0 +1,110 @@
+# {{classname}}{{#description}}
+{{.}}{{/description}}
+
+All URIs are relative to *{{basePath}}*
+
+| Method | HTTP request | Description |
+|------------- | ------------- | -------------|
+{{#operations}}{{#operation}}| [**{{operationId}}**]({{classname}}.md#{{operationId}}) | **{{httpMethod}}** {{path}} | {{summary}} |
+{{/operation}}{{/operations}}
+
+{{#operations}}
+{{#operation}}
+
+# **{{operationId}}**{{^vendorExtensions.x-group-parameters}}
+> {{#returnType}}{{.}} {{/returnType}}{{operationId}}({{#allParams}}{{{paramName}}}{{^-last}}, {{/-last}}{{/allParams}}){{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}
+> {{#returnType}}{{.}} {{/returnType}}{{operationId}}({{#requiredParams}}{{paramName}}{{^-last}}, {{/-last}}{{/requiredParams}}){{#optionalParams}}.{{paramName}}({{paramName}}){{/optionalParams}}.execute();{{/vendorExtensions.x-group-parameters}}
+
+{{summary}}{{#notes}}
+
+{{.}}{{/notes}}
+
+### Example
+```java
+// Import classes:
+import {{{invokerPackage}}}.ApiClient;
+import {{{invokerPackage}}}.ApiException;
+import {{{invokerPackage}}}.Configuration;{{#hasAuthMethods}}
+import {{{invokerPackage}}}.auth.*;{{/hasAuthMethods}}
+import {{{invokerPackage}}}.models.*;
+import {{{package}}}.{{{classname}}};
+
+public class Example {
+ public static void main(String[] args) {
+ ApiClient defaultClient = Configuration.getDefaultApiClient();
+ defaultClient.setBasePath("{{{basePath}}}");
+ {{#withAWSV4Signature}}
+ // Configure AWS Signature V4 authorization
+ defaultClient.setAWS4Configuration("YOUR_ACCESS_KEY", "YOUR_SECRET_KEY", "REGION", "SERVICE")
+ {{/withAWSV4Signature}}
+ {{#hasAuthMethods}}
+ {{#authMethods}}{{#isBasic}}{{#isBasicBasic}}
+ // Configure HTTP basic authorization: {{{name}}}
+ HttpBasicAuth {{{name}}} = (HttpBasicAuth) defaultClient.getAuthentication("{{{name}}}");
+ {{{name}}}.setUsername("YOUR USERNAME");
+ {{{name}}}.setPassword("YOUR PASSWORD");{{/isBasicBasic}}{{#isBasicBearer}}
+ // Configure HTTP bearer authorization: {{{name}}}
+ HttpBearerAuth {{{name}}} = (HttpBearerAuth) defaultClient.getAuthentication("{{{name}}}");
+ {{{name}}}.setBearerToken("BEARER TOKEN");{{/isBasicBearer}}{{/isBasic}}{{#isApiKey}}
+ // Configure API key authorization: {{{name}}}
+ ApiKeyAuth {{{name}}} = (ApiKeyAuth) defaultClient.getAuthentication("{{{name}}}");
+ {{{name}}}.setApiKey("YOUR API KEY");
+ // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
+ //{{{name}}}.setApiKeyPrefix("Token");{{/isApiKey}}{{#isOAuth}}
+ // Configure OAuth2 access token for authorization: {{{name}}}
+ OAuth {{{name}}} = (OAuth) defaultClient.getAuthentication("{{{name}}}");
+ {{{name}}}.setAccessToken("YOUR ACCESS TOKEN");{{/isOAuth}}
+ {{/authMethods}}
+ {{/hasAuthMethods}}
+
+ {{{classname}}} apiInstance = new {{{classname}}}(defaultClient);
+ {{#allParams}}
+ {{{dataType}}} {{{paramName}}} = {{{example}}}; // {{{dataType}}} | {{{description}}}
+ {{/allParams}}
+ try {
+ {{#returnType}}{{{.}}} result = {{/returnType}}apiInstance.{{{operationId}}}{{^vendorExtensions.x-group-parameters}}({{#allParams}}{{{paramName}}}{{^-last}}, {{/-last}}{{/allParams}});{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}({{#requiredParams}}{{{paramName}}}{{^-last}}, {{/-last}}{{/requiredParams}}){{#optionalParams}}
+ .{{{paramName}}}({{{paramName}}}){{/optionalParams}}
+ .execute();{{/vendorExtensions.x-group-parameters}}{{#returnType}}
+ System.out.println(result);{{/returnType}}
+ } catch (ApiException e) {
+ System.err.println("Exception when calling {{{classname}}}#{{{operationId}}}");
+ System.err.println("Status code: " + e.getCode());
+ System.err.println("Reason: " + e.getResponseBody());
+ System.err.println("Response headers: " + e.getResponseHeaders());
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+### Parameters
+{{^allParams}}This endpoint does not need any parameter.{{/allParams}}{{#allParams}}{{#-last}}
+| Name | Type | Description | Notes |
+|------------- | ------------- | ------------- | -------------|{{/-last}}{{/allParams}}
+{{#allParams}}| **{{paramName}}** | {{#isPrimitiveType}}**{{dataType}}**{{/isPrimitiveType}}{{^isPrimitiveType}}{{#isFile}}**{{dataType}}**{{/isFile}}{{^isFile}}[**{{dataType}}**]({{baseType}}.md){{/isFile}}{{/isPrimitiveType}}| {{description}} |{{^required}} [optional]{{/required}}{{^isContainer}}{{#defaultValue}} [default to {{.}}]{{/defaultValue}}{{/isContainer}}{{#allowableValues}} [enum: {{#values}}{{{.}}}{{^-last}}, {{/-last}}{{/values}}]{{/allowableValues}} |
+{{/allParams}}
+
+### Return type
+
+{{#returnType}}{{#returnTypeIsPrimitive}}**{{returnType}}**{{/returnTypeIsPrimitive}}{{^returnTypeIsPrimitive}}[**{{returnType}}**]({{returnBaseType}}.md){{/returnTypeIsPrimitive}}{{/returnType}}{{^returnType}}null (empty response body){{/returnType}}
+
+### Authorization
+
+{{^authMethods}}No authorization required{{/authMethods}}{{#authMethods}}[{{name}}](../README.md#{{name}}){{^-last}}, {{/-last}}{{/authMethods}}
+
+### HTTP request headers
+
+ - **Content-Type**: {{#consumes}}{{{mediaType}}}{{^-last}}, {{/-last}}{{/consumes}}{{^consumes}}Not defined{{/consumes}}
+ - **Accept**: {{#produces}}{{{mediaType}}}{{^-last}}, {{/-last}}{{/produces}}{{^produces}}Not defined{{/produces}}
+
+{{#responses.0}}
+### HTTP response details
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+{{#responses}}
+| **{{code}}** | {{message}} | {{#headers}} * {{baseName}} - {{description}}
{{/headers}}{{^headers.0}} - {{/headers.0}} |
+{{/responses}}
+{{/responses.0}}
+
+{{/operation}}
+{{/operations}}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/api_test.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/api_test.mustache
new file mode 100644
index 000000000000..b56bdf4db09b
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/api_test.mustache
@@ -0,0 +1,65 @@
+{{>licenseInfo}}
+
+package {{package}};
+
+import {{invokerPackage}}.ApiException;
+{{#imports}}import {{import}};
+{{/imports}}
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+{{#supportStreaming}}
+import java.io.InputStream;
+{{/supportStreaming}}
+
+{{#useBeanValidation}}
+import {{javaxPackage}}.validation.constraints.*;
+import {{javaxPackage}}.validation.Valid;
+
+{{/useBeanValidation}}
+/**
+ * API tests for {{classname}}
+ */
+@Disabled
+public class {{classname}}Test {
+
+ private final {{classname}} api = new {{classname}}();
+
+ {{#operations}}
+ {{#operation}}
+ /**
+ {{#summary}}
+ * {{summary}}
+ *
+ {{/summary}}
+ {{#notes}}
+ * {{notes}}
+ *
+ {{/notes}}
+ * @throws ApiException if the Api call fails
+ */
+ @Test
+ public void {{operationId}}Test() throws ApiException {
+ {{#allParams}}
+ {{{dataType}}} {{paramName}} = null;
+ {{/allParams}}
+ {{#vendorExtensions.x-streaming}}
+ InputStream response = api.{{operationId}}{{^vendorExtensions.x-group-parameters}}({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}});{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}({{#requiredParams}}{{paramName}}{{^-last}}, {{/-last}}{{/requiredParams}}){{#optionalParams}}
+ .{{paramName}}({{paramName}}){{/optionalParams}}
+ .execute();{{/vendorExtensions.x-group-parameters}}
+ {{/vendorExtensions.x-streaming}}
+ {{^vendorExtensions.x-streaming}}
+ {{#returnType}}{{{returnType}}} response = {{/returnType}}api.{{operationId}}{{^vendorExtensions.x-group-parameters}}({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}});{{/vendorExtensions.x-group-parameters}}{{#vendorExtensions.x-group-parameters}}({{#requiredParams}}{{paramName}}{{^-last}}, {{/-last}}{{/requiredParams}}){{#optionalParams}}
+ .{{paramName}}({{paramName}}){{/optionalParams}}
+ .execute();{{/vendorExtensions.x-group-parameters}}
+ {{/vendorExtensions.x-streaming}}
+ // TODO: test validations
+ }
+
+ {{/operation}}
+ {{/operations}}
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/AWS4Auth.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/AWS4Auth.mustache
new file mode 100644
index 000000000000..d74c3db611ea
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/AWS4Auth.mustache
@@ -0,0 +1,114 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.Pair;
+import {{invokerPackage}}.ApiException;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import software.amazon.awssdk.auth.credentials.AnonymousCredentialsProvider;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.AwsSessionCredentials;
+import software.amazon.awssdk.auth.credentials.AwsCredentials;
+import software.amazon.awssdk.auth.signer.Aws4Signer;
+import software.amazon.awssdk.auth.signer.params.Aws4SignerParams;
+import software.amazon.awssdk.http.ContentStreamProvider;
+import software.amazon.awssdk.http.SdkHttpFullRequest;
+import software.amazon.awssdk.http.SdkHttpMethod;
+import software.amazon.awssdk.regions.Region;
+
+import okio.Buffer;
+
+{{>generatedAnnotation}}
+
+public class AWS4Auth implements Authentication {
+
+ private AwsCredentials credentials;
+ private String region;
+ private String service;
+
+ public AWS4Auth() {
+ this.credentials = AnonymousCredentialsProvider.create().resolveCredentials();
+ }
+
+ public void setCredentials(String accessKey, String secretKey) {
+ this.credentials = AwsBasicCredentials.create(accessKey, secretKey);
+ }
+
+ public void setCredentials(String accessKey, String secretKey, String sessionToken) {
+ this.credentials = AwsSessionCredentials.create(accessKey, secretKey, sessionToken);
+ }
+
+ public void setRegion(String region) {
+ this.region = region;
+ }
+
+ public void setService(String service) {
+ this.service = service;
+ }
+
+ @Override
+ public void applyToParams(List queryParams, Map headerParams,
+ Map cookieParams, byte[] payload, String method, URI uri)
+ throws ApiException {
+
+ SdkHttpFullRequest.Builder requestBuilder =
+ SdkHttpFullRequest.builder().uri(uri).method(SdkHttpMethod.fromValue(method));
+
+ // SigV4 requires every x-amz-* header that is actually sent to be part of the canonical
+ // request, otherwise AWS rejects the signature. Content-Type is deliberately not signed:
+ // OkHttp's BridgeInterceptor rewrites multipart content types to append the boundary, so the
+ // signed value would not match the value on the wire.
+ for (Map.Entry header : headerParams.entrySet()) {
+ if (header.getKey().toLowerCase(java.util.Locale.ROOT).startsWith("x-amz-")) {
+ requestBuilder.putHeader(header.getKey(), header.getValue());
+ }
+ }
+
+ ContentStreamProvider provider = new ContentStreamProvider() {
+ @Override
+ public InputStream newStream() {
+ return new ByteArrayInputStream(payload);
+ }
+ };
+
+ requestBuilder = requestBuilder.contentStreamProvider(provider);
+
+ SdkHttpFullRequest signableRequest = sign(requestBuilder);
+
+ Map headers = signableRequest.headers().entrySet().stream()
+ .collect(Collectors.toMap(s -> s.getKey(), e -> e.getValue().get(0)));
+
+ headerParams.putAll(headers);
+ }
+
+ /**
+ * AWS Signature Version 4 signing.
+ *
+ * @param request {@link SdkHttpFullRequest.Builder}
+ * @return {@link SdkHttpFullRequest}
+ */
+ private SdkHttpFullRequest sign(final SdkHttpFullRequest.Builder request) {
+
+ SdkHttpFullRequest req = request.build();
+
+ if (this.service != null && this.region != null && this.credentials != null) {
+ Aws4SignerParams params = Aws4SignerParams.builder().signingName(this.service)
+ .signingRegion(Region.of(this.region)).awsCredentials(this.credentials).build();
+
+ Aws4Signer signer = Aws4Signer.create();
+
+ req = signer.sign(req, params);
+ }
+
+ return req;
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/ApiKeyAuth.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/ApiKeyAuth.mustache
new file mode 100644
index 000000000000..31a92bfa5d80
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/ApiKeyAuth.mustache
@@ -0,0 +1,70 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.ApiException;
+import {{invokerPackage}}.Pair;
+
+import java.net.URI;
+import java.util.Map;
+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 queryParams, Map headerParams, Map cookieParams,
+ byte[] payload, String method, URI uri) throws ApiException {
+ 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.put(paramName, value);
+ } else if ("cookie".equals(location)) {
+ cookieParams.put(paramName, value);
+ }
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/Authentication.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/Authentication.mustache
new file mode 100644
index 000000000000..1dee610e63f6
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/Authentication.mustache
@@ -0,0 +1,27 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.Pair;
+import {{invokerPackage}}.ApiException;
+
+import java.net.URI;
+import java.util.Map;
+import java.util.List;
+
+{{>generatedAnnotation}}
+
+public interface Authentication {
+ /**
+ * Apply authentication settings to header and query params.
+ *
+ * @param queryParams List of query parameters
+ * @param headerParams Map of header parameters
+ * @param cookieParams Map of cookie parameters
+ * @param payload HTTP request body
+ * @param method HTTP method
+ * @param uri URI
+ * @throws ApiException if failed to update the parameters
+ */
+ void applyToParams(List queryParams, Map headerParams, Map cookieParams, byte[] payload, String method, URI uri) throws ApiException;
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/HttpBasicAuth.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/HttpBasicAuth.mustache
new file mode 100644
index 000000000000..52e7c07a9be3
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/HttpBasicAuth.mustache
@@ -0,0 +1,44 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.Pair;
+import {{invokerPackage}}.ApiException;
+
+import okhttp3.Credentials;
+
+import java.net.URI;
+import java.util.Map;
+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 queryParams, Map headerParams, Map cookieParams,
+ byte[] payload, String method, URI uri) throws ApiException {
+ if (username == null && password == null) {
+ return;
+ }
+ headerParams.put("Authorization", Credentials.basic(username == null ? "" : username, password == null ? "" : password));
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/HttpBearerAuth.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/HttpBearerAuth.mustache
new file mode 100644
index 000000000000..a1a4b83c46d0
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/HttpBearerAuth.mustache
@@ -0,0 +1,64 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.Pair;
+import {{invokerPackage}}.ApiException;
+
+import java.net.URI;
+import java.util.Map;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+{{>generatedAnnotation}}
+
+public class HttpBearerAuth implements Authentication {
+ private final String scheme;
+ private Supplier tokenSupplier;
+
+ public HttpBearerAuth(String scheme) {
+ this.scheme = scheme;
+ }
+
+ /**
+ * Gets the token, which together with the scheme, will be sent as the value of the Authorization header.
+ *
+ * @return The bearer token
+ */
+ public String getBearerToken() {
+ return tokenSupplier.get();
+ }
+
+ /**
+ * Sets the token, which together with the scheme, will be sent as the value of the Authorization header.
+ *
+ * @param bearerToken The bearer token
+ */
+ public void setBearerToken(String bearerToken) {
+ this.tokenSupplier = () -> bearerToken;
+ }
+
+ /**
+ * Sets the supplier of tokens, which together with the scheme, will be sent as the value of the Authorization header.
+ *
+ * @param tokenSupplier The supplier of bearer tokens
+ */
+ public void setBearerToken(Supplier tokenSupplier) {
+ this.tokenSupplier = tokenSupplier;
+ }
+
+ @Override
+ public void applyToParams(List queryParams, Map headerParams, Map cookieParams,
+ byte[] payload, String method, URI uri) throws ApiException {
+ String bearerToken = Optional.ofNullable(tokenSupplier).map(Supplier::get).orElse(null);
+ if (bearerToken == null) {
+ return;
+ }
+ headerParams.put("Authorization", (scheme != null ? upperCaseBearer(scheme) + " " : "") + bearerToken);
+ }
+
+ private static String upperCaseBearer(String scheme) {
+ return ("bearer".equalsIgnoreCase(scheme)) ? "Bearer" : scheme;
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/OAuth.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/OAuth.mustache
new file mode 100644
index 000000000000..d4032f6ee0f5
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/OAuth.mustache
@@ -0,0 +1,33 @@
+{{>licenseInfo}}
+
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.Pair;
+import {{invokerPackage}}.ApiException;
+
+import java.net.URI;
+import java.util.Map;
+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 queryParams, Map headerParams, Map cookieParams,
+ byte[] payload, String method, URI uri) throws ApiException {
+ if (accessToken == null) {
+ return;
+ }
+ headerParams.put("Authorization", "Bearer " + accessToken);
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/RetryingOAuth.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/RetryingOAuth.mustache
new file mode 100644
index 000000000000..03e37577957d
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/auth/RetryingOAuth.mustache
@@ -0,0 +1,264 @@
+{{>licenseInfo}}
+
+{{#hasOAuthMethods}}
+package {{invokerPackage}}.auth;
+
+import {{invokerPackage}}.ApiException;
+import {{invokerPackage}}.JSON;
+import {{invokerPackage}}.Pair;
+
+import okhttp3.FormBody;
+import okhttp3.Interceptor;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class RetryingOAuth extends OAuth implements Interceptor {
+ private final OkHttpClient client;
+ private final TokenRequestBuilder tokenRequestBuilder;
+ private final JSON json;
+
+ public RetryingOAuth(OkHttpClient client, TokenRequestBuilder tokenRequestBuilder) {
+ this.client = client;
+ this.tokenRequestBuilder = tokenRequestBuilder;
+ this.json = new JSON();
+ }
+
+ public RetryingOAuth(TokenRequestBuilder tokenRequestBuilder) {
+ this(new OkHttpClient(), tokenRequestBuilder);
+ }
+
+ public RetryingOAuth(
+ String tokenUrl,
+ String clientId,
+ OAuthFlow flow,
+ String clientSecret,
+ Map parameters
+ ) {
+ this(TokenRequestBuilder.tokenLocation(tokenUrl)
+ .setClientId(clientId)
+ .setClientSecret(clientSecret));
+ setFlow(flow);
+ if (parameters != null) {
+ for (Map.Entry entry : parameters.entrySet()) {
+ tokenRequestBuilder.setParameter(entry.getKey(), entry.getValue());
+ }
+ }
+ }
+
+ public void setFlow(OAuthFlow flow) {
+ switch(flow) {
+ case ACCESS_CODE:
+ tokenRequestBuilder.setGrantType("authorization_code");
+ break;
+ case IMPLICIT:
+ tokenRequestBuilder.setGrantType("implicit");
+ break;
+ case PASSWORD:
+ tokenRequestBuilder.setGrantType("password");
+ break;
+ case APPLICATION:
+ tokenRequestBuilder.setGrantType("client_credentials");
+ break;
+ default:
+ break;
+ }
+ }
+
+ @Override
+ public Response intercept(Chain chain) throws IOException {
+ return retryingIntercept(chain, true);
+ }
+
+ private Response retryingIntercept(Chain chain, boolean updateTokenAndRetryOnAuthorizationFailure) throws IOException {
+ Request request = chain.request();
+
+ // If the request already has an authorization (e.g. Basic auth), proceed with the request as is
+ if (request.header("Authorization") != null) {
+ return chain.proceed(request);
+ }
+
+ // Get the token if it has not yet been acquired
+ if (getAccessToken() == null) {
+ updateAccessToken(null);
+ }
+
+ if (getAccessToken() != null) {
+ // Build the request
+ Request.Builder requestBuilder = request.newBuilder();
+ requestBuilder.header("Authorization", "Bearer " + getAccessToken());
+
+ // Execute the request
+ Response response = chain.proceed(requestBuilder.build());
+
+ // 401/403 response codes most likely indicate an expired access token, unless it happens two times in a row
+ if (
+ response != null &&
+ ( response.code() == HttpURLConnection.HTTP_UNAUTHORIZED ||
+ response.code() == HttpURLConnection.HTTP_FORBIDDEN ) &&
+ updateTokenAndRetryOnAuthorizationFailure
+ ) {
+ try {
+ String requestAccessToken = getAccessToken();
+ if (updateAccessToken(requestAccessToken)) {
+ if (response.body() != null) {
+ response.body().close();
+ }
+ return retryingIntercept(chain, false);
+ }
+ } catch (Exception e) {
+ if (response.body() != null) {
+ response.body().close();
+ }
+ throw e;
+ }
+ }
+ return response;
+ }
+ else {
+ return chain.proceed(chain.request());
+ }
+ }
+
+ public synchronized boolean updateAccessToken(String requestAccessToken) throws IOException {
+ if (getAccessToken() == null || getAccessToken().equals(requestAccessToken)) {
+ Request tokenRequest = tokenRequestBuilder.build();
+ try (Response response = client.newCall(tokenRequest).execute()) {
+ if (response.isSuccessful() && response.body() != null) {
+ AccessTokenResponse tokenResponse = json.deserialize(response.body().string(), AccessTokenResponse.class);
+ if (tokenResponse != null && tokenResponse.accessToken != null) {
+ setAccessToken(tokenResponse.accessToken);
+ }
+ }
+ }
+ }
+ return getAccessToken() == null || !getAccessToken().equals(requestAccessToken);
+ }
+
+ public TokenRequestBuilder getTokenRequestBuilder() {
+ return tokenRequestBuilder;
+ }
+
+ @Override
+ public void applyToParams(List queryParams, Map headerParams, Map cookieParams,
+ byte[] payload, String method, URI uri) throws ApiException {
+ // No implementation necessary
+ }
+
+ public static class AccessTokenResponse {
+ {{#isJackson}}
+ @com.fasterxml.jackson.annotation.JsonProperty("access_token")
+ {{/isJackson}}
+ {{#isGson}}
+ @com.google.gson.annotations.SerializedName("access_token")
+ {{/isGson}}
+ {{#isJsonb}}
+ @jakarta.json.bind.annotation.JsonbProperty("access_token")
+ {{/isJsonb}}
+ public String accessToken;
+
+ {{#isJackson}}
+ @com.fasterxml.jackson.annotation.JsonProperty("token_type")
+ {{/isJackson}}
+ {{#isGson}}
+ @com.google.gson.annotations.SerializedName("token_type")
+ {{/isGson}}
+ {{#isJsonb}}
+ @jakarta.json.bind.annotation.JsonbProperty("token_type")
+ {{/isJsonb}}
+ public String tokenType;
+
+ {{#isJackson}}
+ @com.fasterxml.jackson.annotation.JsonProperty("expires_in")
+ {{/isJackson}}
+ {{#isGson}}
+ @com.google.gson.annotations.SerializedName("expires_in")
+ {{/isGson}}
+ {{#isJsonb}}
+ @jakarta.json.bind.annotation.JsonbProperty("expires_in")
+ {{/isJsonb}}
+ public Long expiresIn;
+
+ {{#isJackson}}
+ @com.fasterxml.jackson.annotation.JsonProperty("refresh_token")
+ {{/isJackson}}
+ {{#isGson}}
+ @com.google.gson.annotations.SerializedName("refresh_token")
+ {{/isGson}}
+ {{#isJsonb}}
+ @jakarta.json.bind.annotation.JsonbProperty("refresh_token")
+ {{/isJsonb}}
+ public String refreshToken;
+
+ {{#isJackson}}
+ @com.fasterxml.jackson.annotation.JsonProperty("scope")
+ {{/isJackson}}
+ {{#isGson}}
+ @com.google.gson.annotations.SerializedName("scope")
+ {{/isGson}}
+ {{#isJsonb}}
+ @jakarta.json.bind.annotation.JsonbProperty("scope")
+ {{/isJsonb}}
+ public String scope;
+ }
+
+ public static class TokenRequestBuilder {
+ private String tokenUrl;
+ private String clientId;
+ private String clientSecret;
+ private String grantType;
+ private final Map parameters = new HashMap<>();
+
+ public static TokenRequestBuilder tokenLocation(String tokenUrl) {
+ return new TokenRequestBuilder().setTokenUrl(tokenUrl);
+ }
+
+ public TokenRequestBuilder setTokenUrl(String tokenUrl) {
+ this.tokenUrl = tokenUrl;
+ return this;
+ }
+
+ public TokenRequestBuilder setClientId(String clientId) {
+ this.clientId = clientId;
+ return this;
+ }
+
+ public TokenRequestBuilder setClientSecret(String clientSecret) {
+ this.clientSecret = clientSecret;
+ return this;
+ }
+
+ public TokenRequestBuilder setGrantType(String grantType) {
+ this.grantType = grantType;
+ return this;
+ }
+
+ public TokenRequestBuilder setParameter(String name, String value) {
+ this.parameters.put(name, value);
+ return this;
+ }
+
+ public Request build() {
+ FormBody.Builder formBuilder = new FormBody.Builder();
+ if (grantType != null) formBuilder.add("grant_type", grantType);
+ if (clientId != null) formBuilder.add("client_id", clientId);
+ if (clientSecret != null) formBuilder.add("client_secret", clientSecret);
+ for (Map.Entry entry : parameters.entrySet()) {
+ formBuilder.add(entry.getKey(), entry.getValue());
+ }
+
+ return new Request.Builder()
+ .url(tokenUrl)
+ .post(formBuilder.build())
+ .build();
+ }
+ }
+}
+{{/hasOAuthMethods}}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/build.gradle.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/build.gradle.mustache
new file mode 100644
index 000000000000..f1af9bfe63ab
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/build.gradle.mustache
@@ -0,0 +1,140 @@
+apply plugin: 'idea'
+apply plugin: 'eclipse'
+apply plugin: 'java'
+apply plugin: 'maven-publish'
+
+group = '{{groupId}}'
+version = '{{artifactVersion}}'
+
+repositories {
+ mavenCentral()
+}
+{{#sourceFolder}}
+sourceSets {
+ main.java.srcDirs = ['{{sourceFolder}}']
+}
+
+{{/sourceFolder}}
+
+sourceCompatibility = {{#java17}}JavaVersion.VERSION_17{{/java17}}{{^java17}}{{#java11}}JavaVersion.VERSION_11{{/java11}}{{^java11}}JavaVersion.VERSION_1_8{{/java11}}{{/java17}}
+targetCompatibility = {{#java17}}JavaVersion.VERSION_17{{/java17}}{{^java17}}{{#java11}}JavaVersion.VERSION_11{{/java11}}{{^java11}}JavaVersion.VERSION_1_8{{/java11}}{{/java17}}
+
+publishing {
+ publications {
+ maven(MavenPublication) {
+ artifactId = '{{artifactId}}'
+ from components.java
+ }
+ }
+}
+
+task execute(type:JavaExec) {
+ mainClass = System.getProperty('mainClass')
+ classpath = sourceSets.main.runtimeClasspath
+}
+
+ext {
+ {{#swagger1AnnotationLibrary}}
+ swagger_annotations_version = "1.6.6"
+ {{/swagger1AnnotationLibrary}}
+ {{#swagger2AnnotationLibrary}}
+ swagger_annotations_version = "2.2.15"
+ {{/swagger2AnnotationLibrary}}
+ {{#useJakartaEe}}
+ jakarta_annotation_version = "2.1.1"
+ {{#useBeanValidation}}
+ bean_validation_version = "3.0.2"
+ {{/useBeanValidation}}
+ {{/useJakartaEe}}
+ {{^useJakartaEe}}
+ jakarta_annotation_version = "1.3.5"
+ {{#useBeanValidation}}
+ bean_validation_version = "2.0.2"
+ {{/useBeanValidation}}
+ {{/useJakartaEe}}
+ {{#isJackson}}
+ {{#useJackson3}}
+ jackson_version = "3.2.1"
+ {{/useJackson3}}
+ {{^useJackson3}}
+ jackson_version = "2.22.1"
+ {{/useJackson3}}
+ jackson_annotations_version = "2.22"
+ {{/isJackson}}
+ okhttp_version = "5.4.0"
+}
+
+dependencies {
+ {{#swagger1AnnotationLibrary}}
+ implementation "io.swagger:swagger-annotations:$swagger_annotations_version"
+ {{/swagger1AnnotationLibrary}}
+ {{#swagger2AnnotationLibrary}}
+ implementation "io.swagger.core.v3:swagger-annotations:$swagger_annotations_version"
+ {{/swagger2AnnotationLibrary}}
+ {{^useJspecify}}
+ implementation "com.google.code.findbugs:jsr305:3.0.2"
+ {{/useJspecify}}
+ {{#useJspecify}}
+ implementation "org.jspecify:jspecify:1.0.0"
+ {{/useJspecify}}
+ implementation "com.squareup.okhttp3:okhttp:$okhttp_version"
+ implementation "com.squareup.okhttp3:logging-interceptor:$okhttp_version"
+ {{#isGson}}
+ implementation 'com.google.code.gson:gson:2.10.1'
+ implementation 'io.gsonfire:gson-fire:1.9.0'
+ {{/isGson}}
+ {{#isJackson}}
+ implementation "{{jacksonPackage}}.core:jackson-core:$jackson_version"
+ implementation "com.fasterxml.jackson.core:jackson-annotations:$jackson_annotations_version"
+ implementation "{{jacksonPackage}}.core:jackson-databind:$jackson_version"
+ {{^useJackson3}}
+ implementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:$jackson_version"
+ {{/useJackson3}}
+ {{/isJackson}}
+ {{#openApiNullable}}
+ {{^isJsonb}}
+ implementation 'org.openapitools:jackson-databind-nullable:0.2.11'
+ {{/isJsonb}}
+ {{/openApiNullable}}
+ {{#isJsonb}}
+ implementation 'jakarta.json.bind:jakarta.json.bind-api:3.0.1'
+ implementation 'org.eclipse:yasson:3.0.4'
+ implementation 'jakarta.json:jakarta.json-api:2.1.3'
+ implementation 'org.eclipse.parsson:parsson:1.1.7'
+ {{/isJsonb}}
+ {{#withAWSV4Signature}}
+ implementation 'software.amazon.awssdk:auth:2.20.157'
+ {{/withAWSV4Signature}}
+ {{#useReflectionEqualsHashCode}}
+ implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.18.0'
+ {{/useReflectionEqualsHashCode}}
+ {{#joda}}
+ implementation 'joda-time:joda-time:2.12.0'
+ {{/joda}}
+ {{#dynamicOperations}}
+ implementation 'io.swagger.parser.v3:swagger-parser-v3:2.0.30'
+ {{/dynamicOperations}}
+ {{#parcelableModel}}
+ // Needed for Parcelable support
+ compileOnly 'com.google.android:android:4.1.1.4'
+ {{/parcelableModel}}
+ compileOnly "jakarta.annotation:jakarta.annotation-api:$jakarta_annotation_version"
+ {{#useBeanValidation}}
+ compileOnly "jakarta.validation:jakarta.validation-api:$bean_validation_version"
+ {{/useBeanValidation}}
+ testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.3'
+ testImplementation 'org.mockito:mockito-core:3.12.4'
+ testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.3'
+}
+
+javadoc {
+ options.tags = [ "http.response.details:a:Http Response Details" ]
+}
+
+test {
+ useJUnitPlatform()
+ dependsOn 'cleanTest'
+ testLogging {
+ events "passed", "skipped", "failed"
+ }
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/build.sbt.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/build.sbt.mustache
new file mode 100644
index 000000000000..3bb18ec2205a
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/build.sbt.mustache
@@ -0,0 +1,70 @@
+lazy val root = (project in file(".")).
+ settings(
+ organization := "{{groupId}}",
+ name := "{{artifactId}}",
+ version := "{{artifactVersion}}",
+ scalaVersion := "2.13.6",
+ scalacOptions ++= Seq("-feature"),
+ compile / javacOptions ++= Seq("-Xlint:deprecation"),
+ Compile / packageDoc / publishArtifact := false,
+ resolvers += Resolver.mavenLocal,
+ libraryDependencies ++= Seq(
+ {{#swagger1AnnotationLibrary}}
+ "io.swagger" % "swagger-annotations" % "1.6.6",
+ {{/swagger1AnnotationLibrary}}
+ {{#swagger2AnnotationLibrary}}
+ "io.swagger.core.v3" % "swagger-annotations" % "2.2.15",
+ {{/swagger2AnnotationLibrary}}
+ {{^useJspecify}}
+ "com.google.code.findbugs" % "jsr305" % "3.0.2",
+ {{/useJspecify}}
+ {{#useJspecify}}
+ "org.jspecify" % "jspecify" % "1.0.0",
+ {{/useJspecify}}
+ "com.squareup.okhttp3" % "okhttp" % "5.4.0",
+ "com.squareup.okhttp3" % "logging-interceptor" % "5.4.0",
+ {{#isGson}}
+ "com.google.code.gson" % "gson" % "2.10.1",
+ "io.gsonfire" % "gson-fire" % "1.9.0",
+ {{/isGson}}
+ {{#isJackson}}
+ "{{jacksonPackage}}.core" % "jackson-core" % "{{#useJackson3}}3.2.1{{/useJackson3}}{{^useJackson3}}2.22.1{{/useJackson3}}",
+ {{^useJackson3}}
+ "com.fasterxml.jackson.core" % "jackson-annotations" % "2.22",
+ {{/useJackson3}}
+ "{{jacksonPackage}}.core" % "jackson-databind" % "{{#useJackson3}}3.2.1{{/useJackson3}}{{^useJackson3}}2.22.1{{/useJackson3}}",
+ {{^useJackson3}}
+ "com.fasterxml.jackson.datatype" % "jackson-datatype-jsr310" % "2.22.1",
+ {{/useJackson3}}
+ {{/isJackson}}
+ {{#openApiNullable}}
+ {{^isJsonb}}
+ "org.openapitools" % "jackson-databind-nullable" % "0.2.11",
+ {{/isJsonb}}
+ {{/openApiNullable}}
+ {{#isJsonb}}
+ "jakarta.json.bind" % "jakarta.json.bind-api" % "3.0.1",
+ "org.eclipse" % "yasson" % "3.0.4",
+ "jakarta.json" % "jakarta.json-api" % "2.1.3",
+ "org.eclipse.parsson" % "parsson" % "1.1.7",
+ {{/isJsonb}}
+ {{#useReflectionEqualsHashCode}}
+ "org.apache.commons" % "commons-lang3" % "3.18.0",
+ {{/useReflectionEqualsHashCode}}
+ {{#joda}}
+ "joda-time" % "joda-time" % "2.12.0",
+ {{/joda}}
+ "jakarta.annotation" % "jakarta.annotation-api" % "{{#useJakartaEe}}2.1.1{{/useJakartaEe}}{{^useJakartaEe}}1.3.5{{/useJakartaEe}}",
+ {{#withAWSV4Signature}}
+ "software.amazon.awssdk" % "auth" % "2.20.157",
+ {{/withAWSV4Signature}}
+ {{#dynamicOperations}}
+ "io.swagger.parser.v3" % "swagger-parser-v3" % "2.0.30",
+ {{/dynamicOperations}}
+ {{#useBeanValidation}}
+ "jakarta.validation" % "jakarta.validation-api" % "{{#useJakartaEe}}3.0.2{{/useJakartaEe}}{{^useJakartaEe}}2.0.2{{/useJakartaEe}}",
+ {{/useBeanValidation}}
+ "org.junit.jupiter" % "junit-jupiter-api" % "5.10.3" % "test",
+ "com.novocode" % "junit-interface" % "0.10" % "test"
+ )
+ )
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/model.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/model.mustache
new file mode 100644
index 000000000000..213e83ab2bad
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/model.mustache
@@ -0,0 +1,35 @@
+{{>licenseInfo}}
+
+package {{package}};
+
+{{#useReflectionEqualsHashCode}}
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+{{/useReflectionEqualsHashCode}}
+import java.util.Objects;
+{{#imports}}
+import {{import}};
+{{/imports}}
+{{#serializableModel}}
+import java.io.Serializable;
+{{/serializableModel}}
+{{#withXml}}
+import {{javaxPackage}}.xml.bind.annotation.*;
+{{/withXml}}
+{{#parcelableModel}}
+import android.os.Parcelable;
+import android.os.Parcel;
+{{/parcelableModel}}
+{{#useBeanValidation}}
+import {{javaxPackage}}.validation.constraints.*;
+import {{javaxPackage}}.validation.Valid;
+{{/useBeanValidation}}
+{{#performBeanValidation}}
+import org.hibernate.validator.constraints.*;
+{{/performBeanValidation}}
+
+{{#models}}
+{{#model}}
+{{#isEnum}}{{>modelEnum}}{{/isEnum}}{{^isEnum}}{{#vendorExtensions.x-is-one-of-interface}}{{>oneof_interface}}{{/vendorExtensions.x-is-one-of-interface}}{{^vendorExtensions.x-is-one-of-interface}}{{#oneOf}}{{#-first}}{{>oneof_model}}{{/-first}}{{/oneOf}}{{^oneOf}}{{#anyOf}}{{#-first}}{{>anyof_model}}{{/-first}}{{/anyOf}}{{^anyOf}}{{>pojo}}{{/anyOf}}{{/oneOf}}{{/vendorExtensions.x-is-one-of-interface}}{{/isEnum}}
+{{/model}}
+{{/models}}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/modelEnum.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/modelEnum.mustache
new file mode 100644
index 000000000000..6bdfd5e5df9b
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/modelEnum.mustache
@@ -0,0 +1,125 @@
+import java.io.IOException;
+{{#isUri}}
+import java.net.URI;
+{{/isUri}}
+{{#isGson}}
+import com.google.gson.TypeAdapter;
+import com.google.gson.JsonElement;
+import com.google.gson.annotations.JsonAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+{{/isGson}}
+{{#isJackson}}
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+{{/isJackson}}
+{{#isJsonb}}
+import jakarta.json.bind.adapter.JsonbAdapter;
+import jakarta.json.bind.annotation.JsonbTypeAdapter;
+{{/isJsonb}}
+
+/**
+ * {{description}}{{^description}}Gets or Sets {{{name}}}{{/description}}
+ */
+{{#isDeprecated}}
+@Deprecated
+{{/isDeprecated}}
+{{#isGson}}
+@JsonAdapter({{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}.Adapter.class)
+{{/isGson}}
+{{#isJsonb}}{{! JSON-B has no @JsonValue equivalent; without an adapter the constant name would be
+ written instead of the wire value. }}
+@JsonbTypeAdapter({{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}.Adapter.class)
+{{/isJsonb}}
+{{>additionalEnumTypeAnnotations}}public enum {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}{{#vendorExtensions.x-implements}}{{#-first}} implements {{{.}}}{{/-first}}{{^-first}}, {{{.}}}{{/-first}}{{/vendorExtensions.x-implements}} {
+ {{#allowableValues}}{{#enumVars}}
+ {{#enumDescription}}
+ /**
+ * {{.}}
+ */
+ {{/enumDescription}}
+ {{#withXml}}
+ @XmlEnumValue({{#isInteger}}"{{/isInteger}}{{#isDouble}}"{{/isDouble}}{{#isLong}}"{{/isLong}}{{#isFloat}}"{{/isFloat}}{{{value}}}{{#isInteger}}"{{/isInteger}}{{#isDouble}}"{{/isDouble}}{{#isLong}}"{{/isLong}}{{#isFloat}}"{{/isFloat}})
+ {{/withXml}}
+ {{{name}}}({{{value}}}){{^-last}},
+ {{/-last}}{{#-last}};{{/-last}}{{/enumVars}}{{/allowableValues}}
+
+ private {{{dataType}}} value;
+
+ {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}({{{dataType}}} value) {
+ this.value = value;
+ }
+
+ {{#isJackson}}
+ @JsonValue
+ {{/isJackson}}
+ public {{{dataType}}} getValue() {
+ return value;
+ }
+
+ @Override
+ public String toString() {
+ return String.valueOf(value);
+ }
+
+ {{#isJackson}}
+ @JsonCreator
+ {{/isJackson}}
+ public static {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}} fromValue({{{dataType}}} value) {
+ for ({{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}} b : {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}.values()) {
+ if (b.value.equals{{#isString}}{{#useEnumCaseInsensitive}}IgnoreCase{{/useEnumCaseInsensitive}}{{/isString}}(value)) {
+ return b;
+ }
+ }
+ {{#isNullable}}return null;{{/isNullable}}{{^isNullable}}{{#enumUnknownDefaultCase}}{{#allowableValues}}{{#enumVars}}{{#-last}}return {{{name}}};{{/-last}}{{/enumVars}}{{/allowableValues}}{{/enumUnknownDefaultCase}}{{^enumUnknownDefaultCase}}throw new IllegalArgumentException("Unexpected value '" + value + "'");{{/enumUnknownDefaultCase}}{{/isNullable}}
+ }
+
+ {{#isGson}}
+ public static class Adapter extends TypeAdapter<{{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}> {
+ @Override
+ public void write(final JsonWriter jsonWriter, final {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}} enumeration) throws IOException {
+ jsonWriter.value(enumeration.getValue(){{#isUri}}.toASCIIString(){{/isUri}});
+ }
+
+ @Override
+ public {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}} read(final JsonReader jsonReader) throws IOException {
+ {{^isNumber}}{{{dataType}}}{{/isNumber}}{{#isNumber}}String{{/isNumber}} value = {{#isFloat}}(float){{/isFloat}}{{#isUri}}URI.create({{/isUri}}jsonReader.{{#isNumber}}nextString(){{/isNumber}}{{#isInteger}}nextInt(){{/isInteger}}{{#isUri}}nextString()){{/isUri}}{{^isNumber}}{{^isInteger}}{{^isUri}}{{#isFloat}}nextDouble{{/isFloat}}{{^isFloat}}next{{{dataType}}}{{/isFloat}}(){{/isUri}}{{/isInteger}}{{/isNumber}};
+ return {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}.fromValue({{#isNumber}}new java.math.BigDecimal({{/isNumber}}value{{#isNumber}}){{/isNumber}});
+ }
+ }
+
+ public static void validateJsonElement(JsonElement jsonElement) throws IOException {
+ {{^isNumber}}{{{dataType}}}{{/isNumber}}{{#isNumber}}String{{/isNumber}} value = {{#isUri}}URI.create({{/isUri}}jsonElement.{{#isNumber}}getAsString(){{/isNumber}}{{#isInteger}}getAsInt(){{/isInteger}}{{#isUri}}getAsString()){{/isUri}}{{^isNumber}}{{^isInteger}}{{^isUri}}getAs{{{dataType}}}(){{/isUri}}{{/isInteger}}{{/isNumber}};
+ {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}.fromValue({{#isNumber}}new java.math.BigDecimal({{/isNumber}}value{{#isNumber}}){{/isNumber}});
+ }
+ {{/isGson}}
+ {{#isJsonb}}
+ public static class Adapter implements JsonbAdapter<{{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}, {{#isUri}}String{{/isUri}}{{^isUri}}{{{dataType}}}{{/isUri}}> {
+ @Override
+ public {{#isUri}}String{{/isUri}}{{^isUri}}{{{dataType}}}{{/isUri}} adaptToJson({{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}} enumeration) {
+ return enumeration == null ? null : enumeration.getValue(){{#isUri}}.toASCIIString(){{/isUri}};
+ }
+
+ @Override
+ public {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}} adaptFromJson({{#isUri}}String{{/isUri}}{{^isUri}}{{{dataType}}}{{/isUri}} value) {
+ return value == null ? null : {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}.fromValue({{#isUri}}URI.create(value){{/isUri}}{{^isUri}}value{{/isUri}});
+ }
+ }
+ {{/isJsonb}}
+{{#supportUrlQuery}}
+
+ /**
+ * Convert the instance into URL query string.
+ *
+ * @param prefix prefix of the query string
+ * @return URL query string
+ */
+ public String toUrlQueryString(String prefix) {
+ if (prefix == null) {
+ prefix = "";
+ }
+
+ return String.format(java.util.Locale.ROOT, "%s=%s", prefix, this.toString());
+ }
+{{/supportUrlQuery}}
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/modelInnerEnum.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/modelInnerEnum.mustache
new file mode 100644
index 000000000000..607aec303af0
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/modelInnerEnum.mustache
@@ -0,0 +1,93 @@
+ /**
+ * {{description}}{{^description}}Gets or Sets {{{name}}}{{/description}}
+ */
+ {{#isGson}}
+ @JsonAdapter({{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}.Adapter.class)
+ {{/isGson}}
+ {{#isJsonb}}{{! JSON-B has no @JsonValue equivalent; without an adapter the constant name would be
+ written instead of the wire value. }}
+ @JsonbTypeAdapter({{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}.Adapter.class)
+ {{/isJsonb}}
+{{#withXml}}
+ @XmlType(name="{{datatypeWithEnum}}")
+ @XmlEnum({{dataType}}.class)
+{{/withXml}}
+ {{>additionalEnumTypeAnnotations}}public enum {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}{{#vendorExtensions.x-implements}}{{#-first}} implements {{{.}}}{{/-first}}{{^-first}}, {{{.}}}{{/-first}}{{/vendorExtensions.x-implements}} {
+ {{#allowableValues}}
+ {{#enumVars}}
+ {{#enumDescription}}
+ /**
+ * {{.}}
+ */
+ {{/enumDescription}}
+ {{#withXml}}
+ @XmlEnumValue({{#isInteger}}"{{/isInteger}}{{#isDouble}}"{{/isDouble}}{{#isLong}}"{{/isLong}}{{#isFloat}}"{{/isFloat}}{{{value}}}{{#isInteger}}"{{/isInteger}}{{#isDouble}}"{{/isDouble}}{{#isLong}}"{{/isLong}}{{#isFloat}}"{{/isFloat}})
+ {{/withXml}}
+ {{{name}}}({{{value}}}){{^-last}},
+ {{/-last}}{{#-last}};{{/-last}}
+ {{/enumVars}}
+ {{/allowableValues}}
+
+ private {{{dataType}}} value;
+
+ {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}({{{dataType}}} value) {
+ this.value = value;
+ }
+
+ {{#isJackson}}
+ @JsonValue
+ {{/isJackson}}
+ public {{{dataType}}} getValue() {
+ return value;
+ }
+
+ @Override
+ public String toString() {
+ return String.valueOf(value);
+ }
+
+ {{#isJackson}}
+ @JsonCreator
+ {{/isJackson}}
+ public static {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}} fromValue({{{dataType}}} value) {
+ for ({{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}} b : {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}.values()) {
+ if (b.value.equals{{#isString}}{{#useEnumCaseInsensitive}}IgnoreCase{{/useEnumCaseInsensitive}}{{/isString}}(value)) {
+ return b;
+ }
+ }
+ {{#isNullable}}return null;{{/isNullable}}{{^isNullable}}{{#enumUnknownDefaultCase}}{{#allowableValues}}{{#enumVars}}{{#-last}}return {{{name}}};{{/-last}}{{/enumVars}}{{/allowableValues}}{{/enumUnknownDefaultCase}}{{^enumUnknownDefaultCase}}throw new IllegalArgumentException("Unexpected value '" + value + "'");{{/enumUnknownDefaultCase}}{{/isNullable}}
+ }
+
+ {{#isGson}}
+ public static class Adapter extends TypeAdapter<{{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}> {
+ @Override
+ public void write(final JsonWriter jsonWriter, final {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}} enumeration) throws IOException {
+ jsonWriter.value(enumeration.getValue(){{#isUri}}.toASCIIString(){{/isUri}});
+ }
+
+ @Override
+ public {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}} read(final JsonReader jsonReader) throws IOException {
+ {{^isNumber}}{{{dataType}}}{{/isNumber}}{{#isNumber}}String{{/isNumber}} value = {{#isFloat}}(float){{/isFloat}} {{#isUri}}URI.create({{/isUri}}jsonReader.{{#isNumber}}nextString(){{/isNumber}}{{#isInteger}}nextInt(){{/isInteger}}{{#isUri}}nextString()){{/isUri}}{{^isNumber}}{{^isInteger}}{{^isUri}}{{#isFloat}}nextDouble{{/isFloat}}{{^isFloat}}next{{{dataType}}}{{/isFloat}}(){{/isUri}}{{/isInteger}}{{/isNumber}};
+ return {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}.fromValue({{#isNumber}}new java.math.BigDecimal({{/isNumber}}value{{#isNumber}}){{/isNumber}});
+ }
+ }
+
+ public static void validateJsonElement(JsonElement jsonElement) throws IOException {
+ {{^isNumber}}{{{dataType}}}{{/isNumber}}{{#isNumber}}String{{/isNumber}} value = {{#isUri}}URI.create({{/isUri}}jsonElement.{{#isNumber}}getAsString(){{/isNumber}}{{#isInteger}}getAsInt(){{/isInteger}}{{#isUri}}getAsString()){{/isUri}}{{^isNumber}}{{^isInteger}}{{^isUri}}getAs{{{dataType}}}(){{/isUri}}{{/isInteger}}{{/isNumber}};
+ {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}}.fromValue({{#isNumber}}new java.math.BigDecimal({{/isNumber}}value{{#isNumber}}){{/isNumber}});
+ }
+ {{/isGson}}
+ {{#isJsonb}}
+ public static class Adapter implements JsonbAdapter<{{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}, {{#isUri}}String{{/isUri}}{{^isUri}}{{{dataType}}}{{/isUri}}> {
+ @Override
+ public {{#isUri}}String{{/isUri}}{{^isUri}}{{{dataType}}}{{/isUri}} adaptToJson({{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}} enumeration) {
+ return enumeration == null ? null : enumeration.getValue(){{#isUri}}.toASCIIString(){{/isUri}};
+ }
+
+ @Override
+ public {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}} adaptFromJson({{#isUri}}String{{/isUri}}{{^isUri}}{{{dataType}}}{{/isUri}} value) {
+ return value == null ? null : {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}.fromValue({{#isUri}}URI.create(value){{/isUri}}{{^isUri}}value{{/isUri}});
+ }
+ }
+ {{/isJsonb}}
+ }
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/model_test.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/model_test.mustache
new file mode 100644
index 000000000000..eb1643edf8cc
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/model_test.mustache
@@ -0,0 +1,43 @@
+{{>licenseInfo}}
+
+package {{package}};
+
+{{! The model's import list is serialization-library specific and nothing below uses it: the test bodies
+ are stubs and the model itself is in this package. Echoing it here pulled Jackson annotations into
+ Gson and JSON-B builds, which do not have them on the classpath. }}
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Model tests for {{classname}}
+ */
+public class {{classname}}Test {
+ {{#models}}
+ {{#model}}
+ {{^vendorExtensions.x-is-one-of-interface}}
+ {{^isEnum}}
+ private final {{classname}} model = new {{classname}}();
+
+ {{/isEnum}}
+ /**
+ * Model tests for {{classname}}
+ */
+ @Test
+ public void test{{classname}}() {
+ // TODO: test {{classname}}
+ }
+
+ {{#allVars}}
+ /**
+ * Test the property '{{name}}'
+ */
+ @Test
+ public void {{name}}Test() {
+ // TODO: test {{name}}
+ }
+
+ {{/allVars}}
+ {{/vendorExtensions.x-is-one-of-interface}}
+ {{/model}}
+ {{/models}}
+}
diff --git a/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/oneof_model.mustache b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/oneof_model.mustache
new file mode 100644
index 000000000000..75193caf9ea4
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Java/libraries/okhttp/oneof_model.mustache
@@ -0,0 +1,1011 @@
+{{#isGson}}
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonParseException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.annotations.JsonAdapter;
+import com.google.gson.annotations.SerializedName;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonArray;
+{{/isGson}}
+{{#isJackson}}
+{{#isAdditionalPropertiesTrue}}
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+{{/isAdditionalPropertiesTrue}}
+import {{jacksonPackage}}.core.JsonGenerator;
+import {{jacksonPackage}}.core.JsonParser;
+import {{jacksonPackage}}.core.JsonToken;
+import {{jacksonPackage}}.core.type.TypeReference;
+import {{jacksonPackage}}.databind.DeserializationContext;
+{{^useJackson3}}
+import {{jacksonPackage}}.databind.JsonMappingException;
+{{/useJackson3}}
+import {{jacksonPackage}}.databind.JsonNode;
+import {{jacksonPackage}}.databind.MapperFeature;
+{{^useJackson3}}
+import {{jacksonPackage}}.databind.SerializerProvider;
+{{/useJackson3}}
+import {{jacksonPackage}}.databind.annotation.JsonDeserialize;
+import {{jacksonPackage}}.databind.annotation.JsonSerialize;
+import {{jacksonPackage}}.databind.deser.std.StdDeserializer;
+import {{jacksonPackage}}.databind.ser.std.StdSerializer;
+import {{jacksonPackage}}.databind.JavaType;
+{{#useJackson3}}
+import {{jacksonPackage}}.core.JacksonException;
+import {{jacksonPackage}}.databind.DatabindException;
+import {{jacksonPackage}}.databind.SerializationContext;
+{{/useJackson3}}
+{{/isJackson}}
+
+{{#isJsonb}}
+import jakarta.json.bind.annotation.JsonbTypeDeserializer;
+import jakarta.json.bind.annotation.JsonbTypeSerializer;
+import jakarta.json.bind.serializer.DeserializationContext;
+import jakarta.json.bind.serializer.JsonbDeserializer;
+import jakarta.json.bind.serializer.JsonbSerializer;
+import jakarta.json.bind.serializer.SerializationContext;
+import jakarta.json.stream.JsonGenerator;
+import jakarta.json.stream.JsonParser;
+import jakarta.json.JsonObject;
+{{/isJsonb}}
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.StringJoiner;
+
+import {{invokerPackage}}.JSON;
+
+{{>additionalModelTypeAnnotations}}{{>generatedAnnotation}}{{>xmlAnnotation}}
+{{#isJackson}}
+@JsonDeserialize(using = {{classname}}.{{classname}}Deserializer.class)
+@JsonSerialize(using = {{classname}}.{{classname}}Serializer.class)
+{{/isJackson}}
+{{#isJsonb}}
+@JsonbTypeDeserializer({{classname}}.{{classname}}Deserializer.class)
+@JsonbTypeSerializer({{classname}}.{{classname}}Serializer.class)
+{{/isJsonb}}
+public class {{classname}} extends AbstractOpenApiSchema{{#vendorExtensions.x-implements}} implements {{{.}}}{{^-last}}, {{/-last}}{{/vendorExtensions.x-implements}} {
+ private static final Logger log = Logger.getLogger({{classname}}.class.getName());
+
+{{>additional_properties}}
+ {{#isAdditionalPropertiesTrue}}
+ {{#isGson}}
+ /**
+ * Record the properties that the matched oneOf schema did not consume.
+ *
+ * The wrapper only owns what the selected child schema left behind. When that child accepts
+ * additional properties itself it absorbs them all and this records nothing, so a property is
+ * never stored — and therefore never written — twice.
+ */
+ private static void collectUnconsumedProperties({{classname}} instance, JsonElement jsonElement, Gson gson) {
+ if (jsonElement == null || !jsonElement.isJsonObject() || instance.getActualInstance() == null) {
+ return;
+ }
+ JsonElement consumedElement = gson.toJsonTree(instance.getActualInstance());
+ if (consumedElement == null || !consumedElement.isJsonObject()) {
+ return;
+ }
+ JsonObject consumed = consumedElement.getAsJsonObject();
+ for (Map.Entry entry : jsonElement.getAsJsonObject().entrySet()) {
+ if (consumed.has(entry.getKey())) {
+ continue;
+ }
+ JsonElement value = entry.getValue();
+ if (value.isJsonPrimitive()) {
+ JsonPrimitive primitive = value.getAsJsonPrimitive();
+ if (primitive.isString()) {
+ instance.putAdditionalProperty(entry.getKey(), primitive.getAsString());
+ } else if (primitive.isNumber()) {
+ instance.putAdditionalProperty(entry.getKey(), primitive.getAsNumber());
+ } else if (primitive.isBoolean()) {
+ instance.putAdditionalProperty(entry.getKey(), primitive.getAsBoolean());
+ }
+ } else if (value.isJsonArray()) {
+ instance.putAdditionalProperty(entry.getKey(), gson.fromJson(value, List.class));
+ } else if (value.isJsonObject()) {
+ instance.putAdditionalProperty(entry.getKey(), gson.fromJson(value, HashMap.class));
+ }
+ }
+ }
+
+ /**
+ * Merge the unconsumed properties back into the JSON produced by the matched oneOf schema.
+ */
+ private static void writeUnconsumedProperties({{classname}} value, JsonObject obj, Gson gson) {
+ if (value.getAdditionalProperties() == null) {
+ return;
+ }
+ for (Map.Entry entry : value.getAdditionalProperties().entrySet()) {
+ if (obj.has(entry.getKey())) {
+ // the child schema owns this property
+ continue;
+ }
+ obj.add(entry.getKey(), gson.toJsonTree(entry.getValue()));
+ }
+ }
+ {{/isGson}}
+ {{#isJackson}}
+ /**
+ * Record the properties that the matched oneOf schema did not consume.
+ *
+ * The wrapper only owns what the selected child schema left behind. When that child accepts
+ * additional properties itself it absorbs them all and this records nothing, so a property is
+ * never stored — and therefore never written — twice.
+ */
+ private static void collectUnconsumedProperties({{classname}} instance, JsonNode tree) {
+ if (tree == null || !tree.isObject() || instance.getActualInstance() == null) {
+ return;
+ }
+ JsonNode consumed = JSON.getMapper().valueToTree(instance.getActualInstance());
+ if (consumed == null || !consumed.isObject()) {
+ return;
+ }
+ java.util.Iterator> fields = tree.{{^useJackson3}}fields{{/useJackson3}}{{#useJackson3}}properties{{/useJackson3}}(){{#useJackson3}}.iterator(){{/useJackson3}};
+ while (fields.hasNext()) {
+ Map.Entry entry = fields.next();
+ if (consumed.has(entry.getKey())) {
+ continue;
+ }
+ instance.putAdditionalProperty(entry.getKey(),
+ JSON.getMapper().convertValue(entry.getValue(), Object.class));
+ }
+ }
+ {{/isJackson}}
+ {{/isAdditionalPropertiesTrue}}
+
+ {{#isGson}}
+ /**
+ * Validates the JSON Element and throws an exception if issues found
+ *
+ * @param jsonElement JSON Element
+ * @throws IOException if the JSON Element is invalid with respect to {{classname}}
+ */
+ public static void validateJsonElement(JsonElement jsonElement) throws IOException {
+ int matches = 0;
+ List errorMessages = new ArrayList<>();
+ {{#useOneOfDiscriminatorLookup}}
+ {{#discriminator}}
+ JsonObject jsonObject = jsonElement.getAsJsonObject();
+ if (jsonObject.get("{{{propertyBaseName}}}") == null) {
+ throw new IOException("Failed to deserialize as the discriminator field '{{{propertyBaseName}}}' is missing.");
+ }
+ String discriminatorValue = jsonObject.get("{{{propertyBaseName}}}").getAsString();
+ {{#mappedModels}}
+ if ("{{{mappingName}}}".equals(discriminatorValue)) {
+ {{{modelName}}}.validateJsonElement(jsonElement);
+ return;
+ }
+ {{/mappedModels}}
+ {{/discriminator}}
+ {{/useOneOfDiscriminatorLookup}}
+ {{#composedSchemas}}
+ {{#oneOf}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ // deserialize {{{dataType}}}
+ try {
+ // validate the JSON object to see if any exception is thrown
+ {{#isModel}}
+ {{#hasChildren}}
+ {{{dataType}}}.validateJsonElement(jsonElement);
+ {{/hasChildren}}
+ {{^hasChildren}}
+ {{#isArray}}
+ if (!jsonElement.isJsonArray()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a array type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isArray}}
+ {{^isArray}}
+ {{#isMap}}
+ if (!jsonElement.isJsonObject()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a object type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{^isMap}}
+ {{{dataType}}}.validateJsonElement(jsonElement);
+ {{/isMap}}
+ {{/isArray}}
+ {{/hasChildren}}
+ {{/isModel}}
+ {{#isPrimitiveType}}
+ {{#isArray}}
+ if (!jsonElement.isJsonArray()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a array type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isArray}}
+ {{^isArray}}
+ {{#isMap}}
+ if (!jsonElement.isJsonObject()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a object type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{^isMap}}
+ if (!jsonElement.isJsonPrimitive()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a primitive type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{/isArray}}
+ {{/isPrimitiveType}}
+ matches++;
+ } catch (Exception e) {
+ // deserialization failed, continue
+ errorMessages.add(String.format("Deserialization for {{{dataType}}} failed with `%s`.", e.getMessage()));
+ }
+
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/oneOf}}
+ {{/composedSchemas}}
+ if (matches != 1) {
+ throw new IOException(String.format("Failed deserialization for {{classname}}: %d classes match result, expected 1. %s", matches, errorMessages));
+ }
+ }
+
+ public static class CustomTypeAdapterFactory implements TypeAdapterFactory {
+ @SuppressWarnings("unchecked")
+ @Override
+ public TypeAdapter create(Gson gson, TypeToken type) {
+ if (!{{classname}}.class.isAssignableFrom(type.getRawType())) {
+ return null; // this class only serializes '{{classname}}' and its subtypes
+ }
+ final TypeAdapter elementAdapter = gson.getAdapter(JsonElement.class);
+ {{#composedSchemas}}
+ {{#oneOf}}
+ {{^isArray}}
+ {{^isMap}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ final TypeAdapter<{{{dataType}}}> adapter{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}} = gson.getDelegateAdapter(this, TypeToken.get({{{dataType}}}.class));
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/isMap}}
+ {{/isArray}}
+ {{#isArray}}
+ final Type typeInstance{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}} = new TypeToken<{{{dataType}}}>(){}.getType();
+ final TypeAdapter<{{{dataType}}}> adapter{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}} = (TypeAdapter<{{{dataType}}}>) gson.getDelegateAdapter(this, TypeToken.get(typeInstance{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}}));
+ {{/isArray}}
+ {{#isMap}}
+ final Type typeInstance{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}} = new TypeToken<{{{dataType}}}>(){}.getType();
+ final TypeAdapter<{{{dataType}}}> adapter{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}} = (TypeAdapter<{{{dataType}}}>) gson.getDelegateAdapter(this, TypeToken.get(typeInstance{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}}));
+ {{/isMap}}
+ {{/oneOf}}
+ {{/composedSchemas}}
+
+ return (TypeAdapter) new TypeAdapter<{{classname}}>() {
+ @Override
+ public void write(JsonWriter out, {{classname}} value) throws IOException {
+ if (value == null || value.getActualInstance() == null) {
+ elementAdapter.write(out, null);
+ return;
+ }
+
+ JsonElement element = null;
+ {{#composedSchemas}}
+ {{#oneOf}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ // check if the actual instance is of the type `{{{dataType}}}`
+ if (value.getActualInstance() instanceof {{#isArray}}List{{/isArray}}{{#isMap}}Map{{/isMap}}{{^isMap}}{{^isArray}}{{{dataType}}}{{/isArray}}{{/isMap}}) {
+ element = adapter{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}}.toJsonTree(({{{dataType}}})value.getActualInstance());
+ }
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/oneOf}}
+ {{/composedSchemas}}
+
+ if (element == null) {
+ throw new IOException("Failed to serialize as the type doesn't match oneOf schemas: {{#oneOf}}{{{.}}}{{^-last}}, {{/-last}}{{/oneOf}}");
+ }
+
+ {{#isAdditionalPropertiesTrue}}
+ if (element.isJsonObject()) {
+ writeUnconsumedProperties(value, element.getAsJsonObject(), gson);
+ }
+ {{/isAdditionalPropertiesTrue}}
+ elementAdapter.write(out, element);
+ }
+
+ @Override
+ public {{classname}} read(JsonReader in) throws IOException {
+ Object deserialized = null;
+ JsonElement jsonElement = elementAdapter.read(in);
+
+ {{#useOneOfDiscriminatorLookup}}
+ {{#discriminator}}
+ JsonObject jsonObject = jsonElement.getAsJsonObject();
+ if (jsonObject.get("{{{propertyBaseName}}}") == null) {
+ throw new IOException("Failed to deserialize as the discriminator field '{{{propertyBaseName}}}' is missing.");
+ }
+ String discriminatorValue = jsonObject.get("{{{propertyBaseName}}}").getAsString();
+ {{#mappedModels}}
+ if ("{{{mappingName}}}".equals(discriminatorValue)) {
+ deserialized = adapter{{#sanitizeDataType}}{{{modelName}}}{{/sanitizeDataType}}.fromJsonTree(jsonElement);
+ {{classname}} ret = new {{classname}}();
+ ret.setActualInstance(deserialized);
+ {{#isAdditionalPropertiesTrue}}
+ collectUnconsumedProperties(ret, jsonElement, gson);
+ {{/isAdditionalPropertiesTrue}}
+ return ret;
+ }
+ {{/mappedModels}}
+ {{/discriminator}}
+ {{/useOneOfDiscriminatorLookup}}
+
+ int match = 0;
+ ArrayList errorMessages = new ArrayList<>();
+ TypeAdapter actualAdapter = null;
+
+ {{#composedSchemas}}
+ {{#oneOf}}
+ {{^vendorExtensions.x-duplicated-data-type}}
+ // deserialize {{{dataType}}}
+ try {
+ // validate the JSON object to see if any exception is thrown
+ {{#isModel}}
+ {{#hasChildren}}
+ {{{dataType}}}.validateJsonElement(jsonElement);
+ {{/hasChildren}}
+ {{^hasChildren}}
+ {{#isArray}}
+ if (!jsonElement.isJsonArray()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a array type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isArray}}
+ {{^isArray}}
+ {{#isMap}}
+ if (!jsonElement.isJsonObject()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a object type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{^isMap}}
+ {{{dataType}}}.validateJsonElement(jsonElement);
+ {{/isMap}}
+ {{/isArray}}
+ {{/hasChildren}}
+ {{/isModel}}
+ {{#isPrimitiveType}}
+ {{#isArray}}
+ if (!jsonElement.isJsonArray()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a array type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isArray}}
+ {{^isArray}}
+ {{#isMap}}
+ if (!jsonElement.isJsonObject()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a object type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{^isMap}}
+ if (!jsonElement.isJsonPrimitive()) {
+ throw new IllegalArgumentException(String.format("Expected json element to be a primitive type in the JSON string but got `%s`", jsonElement.toString()));
+ }
+ {{/isMap}}
+ {{/isArray}}
+ {{/isPrimitiveType}}
+ actualAdapter = adapter{{#sanitizeDataType}}{{{dataType}}}{{/sanitizeDataType}};
+ match++;
+ log.log(Level.FINER, "Input data matches schema '{{{dataType}}}'");
+ } catch (Exception e) {
+ // deserialization failed, continue
+ errorMessages.add(String.format("Deserialization for {{{dataType}}} failed with `%s`.", e.getMessage()));
+ log.log(Level.FINER, "Input data does not match schema '{{{dataType}}}'", e);
+ }
+
+ {{/vendorExtensions.x-duplicated-data-type}}
+ {{/oneOf}}
+ {{/composedSchemas}}
+ if (match == 1) {
+ {{classname}} ret = new {{classname}}();
+ ret.setActualInstance(actualAdapter.fromJsonTree(jsonElement));
+ {{#isAdditionalPropertiesTrue}}
+ collectUnconsumedProperties(ret, jsonElement, gson);
+ {{/isAdditionalPropertiesTrue}}
+ return ret;
+ }
+
+ throw new IOException(String.format("Failed deserialization for {{classname}}: %d classes match result, expected 1. %s", match, errorMessages));
+ }
+ };
+ }
+ }
+ {{/isGson}}
+
+ {{#isJackson}}
+ public static class {{classname}}Serializer extends StdSerializer<{{classname}}> {
+ public {{classname}}Serializer(Class<{{classname}}> t) {
+ super(t);
+ }
+
+ public {{classname}}Serializer() {
+ this(null);
+ }
+
+ @Override
+ public void serialize({{classname}} value, JsonGenerator jgen, {{^useJackson3}}SerializerProvider provider{{/useJackson3}}{{#useJackson3}}SerializationContext serializationContext{{/useJackson3}}) throws {{^useJackson3}}IOException{{/useJackson3}}{{#useJackson3}}JacksonException{{/useJackson3}} {
+ {{#isAdditionalPropertiesTrue}}
+ {{! @JsonAnyGetter is ignored on a class with a custom serializer, so the unconsumed
+ properties have to be merged into the child's tree by hand. }}
+ if (value.getActualInstance() != null && value.getAdditionalProperties() != null
+ && !value.getAdditionalProperties().isEmpty()) {
+ JsonNode node = JSON.getMapper().valueToTree(value.getActualInstance());
+ if (node != null && node.isObject()) {
+ {{jacksonPackage}}.databind.node.ObjectNode objectNode = ({{jacksonPackage}}.databind.node.ObjectNode) node;
+ for (Map.Entry entry : value.getAdditionalProperties().entrySet()) {
+ if (objectNode.has(entry.getKey())) {
+ // the child schema owns this property
+ continue;
+ }
+ objectNode.set(entry.getKey(), JSON.getMapper().valueToTree(entry.getValue()));
+ }
+ {{^useJackson3}}
+ jgen.writeTree(node);
+ {{/useJackson3}}
+ {{#useJackson3}}
+ serializationContext.writeValue(jgen, node);
+ {{/useJackson3}}
+ return;
+ }
+ }
+ {{/isAdditionalPropertiesTrue}}
+ {{^useJackson3}}
+ jgen.writeObject(value.getActualInstance());
+ {{/useJackson3}}
+ {{#useJackson3}}
+ serializationContext.writeValue(jgen, value.getActualInstance());
+ {{/useJackson3}}
+ }
+ }
+
+ public static class {{classname}}Deserializer extends StdDeserializer<{{classname}}> {
+ public {{classname}}Deserializer() {
+ this({{classname}}.class);
+ }
+
+ public {{classname}}Deserializer(Class vc) {
+ super(vc);
+ }
+
+ @Override
+ public {{classname}} deserialize(JsonParser jp, DeserializationContext ctxt) throws {{^useJackson3}}IOException{{/useJackson3}}{{#useJackson3}}JacksonException{{/useJackson3}} {
+ JsonNode tree = ctxt.readTree(jp);
+ Object deserialized = null;
+ {{#useOneOfDiscriminatorLookup}}
+ {{#discriminator}}
+ {{classname}} new{{classname}} = new {{classname}}();
+ {{^useJackson3}}
+ Map result2 = tree.traverse(jp.getCodec()).readValueAs(new TypeReference