content: /*
   * VerificationService
   * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
   *
   * The version of the OpenAPI document: 1.0.0
   * Contact: info@affinidi.com
   *
   * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
   * https://openapi-generator.tech
   * Do not edit the class manually.
   */
  
  
  package com.affinidi.tdk.credential.verification.client.models;
  
  import java.util.Objects;
  import java.util.Arrays;
  import com.affinidi.tdk.credential.verification.client.models.FilterConst;
  import com.affinidi.tdk.credential.verification.client.models.FilterItems;
  import com.fasterxml.jackson.annotation.JsonInclude;
  import com.fasterxml.jackson.annotation.JsonProperty;
  import com.fasterxml.jackson.annotation.JsonCreator;
  import com.fasterxml.jackson.annotation.JsonTypeName;
  import com.fasterxml.jackson.annotation.JsonValue;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  import com.fasterxml.jackson.annotation.JsonPropertyOrder;
  import com.fasterxml.jackson.annotation.JsonTypeName;
  import java.io.UnsupportedEncodingException;
  import java.net.URLEncoder;
  import java.util.StringJoiner;
  
  /**
   * Filter
   */
  @JsonPropertyOrder({
    Filter.JSON_PROPERTY_CONST,
    Filter.JSON_PROPERTY_ENUM,
    Filter.JSON_PROPERTY_EXCLUSIVE_MINIMUM,
    Filter.JSON_PROPERTY_EXCLUSIVE_MAXIMUM,
    Filter.JSON_PROPERTY_FORMAT,
    Filter.JSON_PROPERTY_FORMAT_MAXIMUM,
    Filter.JSON_PROPERTY_FORMAT_MINIMUM,
    Filter.JSON_PROPERTY_FORMAT_EXCLUSIVE_MAXIMUM,
    Filter.JSON_PROPERTY_FORMAT_EXCLUSIVE_MINIMUM,
    Filter.JSON_PROPERTY_MIN_LENGTH,
    Filter.JSON_PROPERTY_MAX_LENGTH,
    Filter.JSON_PROPERTY_MINIMUM,
    Filter.JSON_PROPERTY_MAXIMUM,
    Filter.JSON_PROPERTY_NOT,
    Filter.JSON_PROPERTY_PATTERN,
    Filter.JSON_PROPERTY_CONTAINS,
    Filter.JSON_PROPERTY_ITEMS,
    Filter.JSON_PROPERTY_TYPE
  })
  @javax.annotation.Generated(value = "org.openapitools.codegen.languages.JavaClientCodegen", comments = "Generator version: 7.13.0")
  public class Filter {
    public static final String JSON_PROPERTY_CONST = "_const";
    @javax.annotation.Nullable
    private FilterConst _const;
  
    public static final String JSON_PROPERTY_ENUM = "_enum";
    @javax.annotation.Nullable
    private List<FilterConst> _enum = new ArrayList<>();
  
    public static final String JSON_PROPERTY_EXCLUSIVE_MINIMUM = "exclusiveMinimum";
    @javax.annotation.Nullable
    private FilterConst exclusiveMinimum;
  
    public static final String JSON_PROPERTY_EXCLUSIVE_MAXIMUM = "exclusiveMaximum";
    @javax.annotation.Nullable
    private FilterConst exclusiveMaximum;
  
    public static final String JSON_PROPERTY_FORMAT = "format";
    @javax.annotation.Nullable
    private String format;
  
    public static final String JSON_PROPERTY_FORMAT_MAXIMUM = "formatMaximum";
    @javax.annotation.Nullable
    private String formatMaximum;
  
    public static final String JSON_PROPERTY_FORMAT_MINIMUM = "formatMinimum";
    @javax.annotation.Nullable
    private String formatMinimum;
  
    public static final String JSON_PROPERTY_FORMAT_EXCLUSIVE_MAXIMUM = "formatExclusiveMaximum";
    @javax.annotation.Nullable
    private String formatExclusiveMaximum;
  
    public static final String JSON_PROPERTY_FORMAT_EXCLUSIVE_MINIMUM = "formatExclusiveMinimum";
    @javax.annotation.Nullable
    private String formatExclusiveMinimum;
  
    public static final String JSON_PROPERTY_MIN_LENGTH = "minLength";
    @javax.annotation.Nullable
    private Integer minLength;
  
    public static final String JSON_PROPERTY_MAX_LENGTH = "maxLength";
    @javax.annotation.Nullable
    private Integer maxLength;
  
    public static final String JSON_PROPERTY_MINIMUM = "minimum";
    @javax.annotation.Nullable
    private FilterConst minimum;
  
    public static final String JSON_PROPERTY_MAXIMUM = "maximum";
    @javax.annotation.Nullable
    private FilterConst maximum;
  
    public static final String JSON_PROPERTY_NOT = "not";
    @javax.annotation.Nullable
    private Object not;
  
    public static final String JSON_PROPERTY_PATTERN = "pattern";
    @javax.annotation.Nullable
    private String pattern;
  
    public static final String JSON_PROPERTY_CONTAINS = "contains";
    @javax.annotation.Nullable
    private Filter contains;
  
    public static final String JSON_PROPERTY_ITEMS = "items";
    @javax.annotation.Nullable
    private FilterItems items;
  
    public static final String JSON_PROPERTY_TYPE = "type";
    @javax.annotation.Nullable
    private String type;
  
    public Filter() {
    }
  
    public Filter _const(@javax.annotation.Nullable FilterConst _const) {
      
      this._const = _const;
      return this;
    }
  
    /**
     * Get _const
     * @return _const
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_CONST)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public FilterConst getConst() {
      return _const;
    }
  
  
    @JsonProperty(JSON_PROPERTY_CONST)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setConst(@javax.annotation.Nullable FilterConst _const) {
      this._const = _const;
    }
  
    public Filter _enum(@javax.annotation.Nullable List<FilterConst> _enum) {
      
      this._enum = _enum;
      return this;
    }
  
    public Filter addEnumItem(FilterConst _enumItem) {
      if (this._enum == null) {
        this._enum = new ArrayList<>();
      }
      this._enum.add(_enumItem);
      return this;
    }
  
    /**
     * Get _enum
     * @return _enum
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_ENUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public List<FilterConst> getEnum() {
      return _enum;
    }
  
  
    @JsonProperty(JSON_PROPERTY_ENUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setEnum(@javax.annotation.Nullable List<FilterConst> _enum) {
      this._enum = _enum;
    }
  
    public Filter exclusiveMinimum(@javax.annotation.Nullable FilterConst exclusiveMinimum) {
      
      this.exclusiveMinimum = exclusiveMinimum;
      return this;
    }
  
    /**
     * Get exclusiveMinimum
     * @return exclusiveMinimum
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_EXCLUSIVE_MINIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public FilterConst getExclusiveMinimum() {
      return exclusiveMinimum;
    }
  
  
    @JsonProperty(JSON_PROPERTY_EXCLUSIVE_MINIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setExclusiveMinimum(@javax.annotation.Nullable FilterConst exclusiveMinimum) {
      this.exclusiveMinimum = exclusiveMinimum;
    }
  
    public Filter exclusiveMaximum(@javax.annotation.Nullable FilterConst exclusiveMaximum) {
      
      this.exclusiveMaximum = exclusiveMaximum;
      return this;
    }
  
    /**
     * Get exclusiveMaximum
     * @return exclusiveMaximum
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_EXCLUSIVE_MAXIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public FilterConst getExclusiveMaximum() {
      return exclusiveMaximum;
    }
  
  
    @JsonProperty(JSON_PROPERTY_EXCLUSIVE_MAXIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setExclusiveMaximum(@javax.annotation.Nullable FilterConst exclusiveMaximum) {
      this.exclusiveMaximum = exclusiveMaximum;
    }
  
    public Filter format(@javax.annotation.Nullable String format) {
      
      this.format = format;
      return this;
    }
  
    /**
     * Get format
     * @return format
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_FORMAT)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public String getFormat() {
      return format;
    }
  
  
    @JsonProperty(JSON_PROPERTY_FORMAT)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setFormat(@javax.annotation.Nullable String format) {
      this.format = format;
    }
  
    public Filter formatMaximum(@javax.annotation.Nullable String formatMaximum) {
      
      this.formatMaximum = formatMaximum;
      return this;
    }
  
    /**
     * Get formatMaximum
     * @return formatMaximum
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_FORMAT_MAXIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public String getFormatMaximum() {
      return formatMaximum;
    }
  
  
    @JsonProperty(JSON_PROPERTY_FORMAT_MAXIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setFormatMaximum(@javax.annotation.Nullable String formatMaximum) {
      this.formatMaximum = formatMaximum;
    }
  
    public Filter formatMinimum(@javax.annotation.Nullable String formatMinimum) {
      
      this.formatMinimum = formatMinimum;
      return this;
    }
  
    /**
     * Get formatMinimum
     * @return formatMinimum
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_FORMAT_MINIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public String getFormatMinimum() {
      return formatMinimum;
    }
  
  
    @JsonProperty(JSON_PROPERTY_FORMAT_MINIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setFormatMinimum(@javax.annotation.Nullable String formatMinimum) {
      this.formatMinimum = formatMinimum;
    }
  
    public Filter formatExclusiveMaximum(@javax.annotation.Nullable String formatExclusiveMaximum) {
      
      this.formatExclusiveMaximum = formatExclusiveMaximum;
      return this;
    }
  
    /**
     * Get formatExclusiveMaximum
     * @return formatExclusiveMaximum
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_FORMAT_EXCLUSIVE_MAXIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public String getFormatExclusiveMaximum() {
      return formatExclusiveMaximum;
    }
  
  
    @JsonProperty(JSON_PROPERTY_FORMAT_EXCLUSIVE_MAXIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setFormatExclusiveMaximum(@javax.annotation.Nullable String formatExclusiveMaximum) {
      this.formatExclusiveMaximum = formatExclusiveMaximum;
    }
  
    public Filter formatExclusiveMinimum(@javax.annotation.Nullable String formatExclusiveMinimum) {
      
      this.formatExclusiveMinimum = formatExclusiveMinimum;
      return this;
    }
  
    /**
     * Get formatExclusiveMinimum
     * @return formatExclusiveMinimum
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_FORMAT_EXCLUSIVE_MINIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public String getFormatExclusiveMinimum() {
      return formatExclusiveMinimum;
    }
  
  
    @JsonProperty(JSON_PROPERTY_FORMAT_EXCLUSIVE_MINIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setFormatExclusiveMinimum(@javax.annotation.Nullable String formatExclusiveMinimum) {
      this.formatExclusiveMinimum = formatExclusiveMinimum;
    }
  
    public Filter minLength(@javax.annotation.Nullable Integer minLength) {
      
      this.minLength = minLength;
      return this;
    }
  
    /**
     * Get minLength
     * @return minLength
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_MIN_LENGTH)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public Integer getMinLength() {
      return minLength;
    }
  
  
    @JsonProperty(JSON_PROPERTY_MIN_LENGTH)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setMinLength(@javax.annotation.Nullable Integer minLength) {
      this.minLength = minLength;
    }
  
    public Filter maxLength(@javax.annotation.Nullable Integer maxLength) {
      
      this.maxLength = maxLength;
      return this;
    }
  
    /**
     * Get maxLength
     * @return maxLength
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_MAX_LENGTH)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public Integer getMaxLength() {
      return maxLength;
    }
  
  
    @JsonProperty(JSON_PROPERTY_MAX_LENGTH)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setMaxLength(@javax.annotation.Nullable Integer maxLength) {
      this.maxLength = maxLength;
    }
  
    public Filter minimum(@javax.annotation.Nullable FilterConst minimum) {
      
      this.minimum = minimum;
      return this;
    }
  
    /**
     * Get minimum
     * @return minimum
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_MINIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public FilterConst getMinimum() {
      return minimum;
    }
  
  
    @JsonProperty(JSON_PROPERTY_MINIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setMinimum(@javax.annotation.Nullable FilterConst minimum) {
      this.minimum = minimum;
    }
  
    public Filter maximum(@javax.annotation.Nullable FilterConst maximum) {
      
      this.maximum = maximum;
      return this;
    }
  
    /**
     * Get maximum
     * @return maximum
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_MAXIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public FilterConst getMaximum() {
      return maximum;
    }
  
  
    @JsonProperty(JSON_PROPERTY_MAXIMUM)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setMaximum(@javax.annotation.Nullable FilterConst maximum) {
      this.maximum = maximum;
    }
  
    public Filter not(@javax.annotation.Nullable Object not) {
      
      this.not = not;
      return this;
    }
  
    /**
     * Get not
     * @return not
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_NOT)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public Object getNot() {
      return not;
    }
  
  
    @JsonProperty(JSON_PROPERTY_NOT)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setNot(@javax.annotation.Nullable Object not) {
      this.not = not;
    }
  
    public Filter pattern(@javax.annotation.Nullable String pattern) {
      
      this.pattern = pattern;
      return this;
    }
  
    /**
     * Get pattern
     * @return pattern
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_PATTERN)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public String getPattern() {
      return pattern;
    }
  
  
    @JsonProperty(JSON_PROPERTY_PATTERN)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setPattern(@javax.annotation.Nullable String pattern) {
      this.pattern = pattern;
    }
  
    public Filter contains(@javax.annotation.Nullable Filter contains) {
      
      this.contains = contains;
      return this;
    }
  
    /**
     * Get contains
     * @return contains
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_CONTAINS)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public Filter getContains() {
      return contains;
    }
  
  
    @JsonProperty(JSON_PROPERTY_CONTAINS)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setContains(@javax.annotation.Nullable Filter contains) {
      this.contains = contains;
    }
  
    public Filter items(@javax.annotation.Nullable FilterItems items) {
      
      this.items = items;
      return this;
    }
  
    /**
     * Get items
     * @return items
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_ITEMS)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public FilterItems getItems() {
      return items;
    }
  
  
    @JsonProperty(JSON_PROPERTY_ITEMS)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setItems(@javax.annotation.Nullable FilterItems items) {
      this.items = items;
    }
  
    public Filter type(@javax.annotation.Nullable String type) {
      
      this.type = type;
      return this;
    }
  
    /**
     * Get type
     * @return type
     */
    @javax.annotation.Nullable
    @JsonProperty(JSON_PROPERTY_TYPE)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
  
    public String getType() {
      return type;
    }
  
  
    @JsonProperty(JSON_PROPERTY_TYPE)
    @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS)
    public void setType(@javax.annotation.Nullable String type) {
      this.type = type;
    }
  
    @Override
    public boolean equals(Object o) {
      if (this == o) {
        return true;
      }
      if (o == null || getClass() != o.getClass()) {
        return false;
      }
      Filter filter = (Filter) o;
      return Objects.equals(this._const, filter._const) &&
          Objects.equals(this._enum, filter._enum) &&
          Objects.equals(this.exclusiveMinimum, filter.exclusiveMinimum) &&
          Objects.equals(this.exclusiveMaximum, filter.exclusiveMaximum) &&
          Objects.equals(this.format, filter.format) &&
          Objects.equals(this.formatMaximum, filter.formatMaximum) &&
          Objects.equals(this.formatMinimum, filter.formatMinimum) &&
          Objects.equals(this.formatExclusiveMaximum, filter.formatExclusiveMaximum) &&
          Objects.equals(this.formatExclusiveMinimum, filter.formatExclusiveMinimum) &&
          Objects.equals(this.minLength, filter.minLength) &&
          Objects.equals(this.maxLength, filter.maxLength) &&
          Objects.equals(this.minimum, filter.minimum) &&
          Objects.equals(this.maximum, filter.maximum) &&
          Objects.equals(this.not, filter.not) &&
          Objects.equals(this.pattern, filter.pattern) &&
          Objects.equals(this.contains, filter.contains) &&
          Objects.equals(this.items, filter.items) &&
          Objects.equals(this.type, filter.type);
    }
  
    @Override
    public int hashCode() {
      return Objects.hash(_const, _enum, exclusiveMinimum, exclusiveMaximum, format, formatMaximum, formatMinimum, formatExclusiveMaximum, formatExclusiveMinimum, minLength, maxLength, minimum, maximum, not, pattern, contains, items, type);
    }
  
    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder();
      sb.append("class Filter {\n");
      sb.append("    _const: ").append(toIndentedString(_const)).append("\n");
      sb.append("    _enum: ").append(toIndentedString(_enum)).append("\n");
      sb.append("    exclusiveMinimum: ").append(toIndentedString(exclusiveMinimum)).append("\n");
      sb.append("    exclusiveMaximum: ").append(toIndentedString(exclusiveMaximum)).append("\n");
      sb.append("    format: ").append(toIndentedString(format)).append("\n");
      sb.append("    formatMaximum: ").append(toIndentedString(formatMaximum)).append("\n");
      sb.append("    formatMinimum: ").append(toIndentedString(formatMinimum)).append("\n");
      sb.append("    formatExclusiveMaximum: ").append(toIndentedString(formatExclusiveMaximum)).append("\n");
      sb.append("    formatExclusiveMinimum: ").append(toIndentedString(formatExclusiveMinimum)).append("\n");
      sb.append("    minLength: ").append(toIndentedString(minLength)).append("\n");
      sb.append("    maxLength: ").append(toIndentedString(maxLength)).append("\n");
      sb.append("    minimum: ").append(toIndentedString(minimum)).append("\n");
      sb.append("    maximum: ").append(toIndentedString(maximum)).append("\n");
      sb.append("    not: ").append(toIndentedString(not)).append("\n");
      sb.append("    pattern: ").append(toIndentedString(pattern)).append("\n");
      sb.append("    contains: ").append(toIndentedString(contains)).append("\n");
      sb.append("    items: ").append(toIndentedString(items)).append("\n");
      sb.append("    type: ").append(toIndentedString(type)).append("\n");
      sb.append("}");
      return sb.toString();
    }
  
    /**
     * Convert the given object to string with each line indented by 4 spaces
     * (except the first line).
     */
    private String toIndentedString(Object o) {
      if (o == null) {
        return "null";
      }
      return o.toString().replace("\n", "\n    ");
    }
  
    /**
     * 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("&");
  
      // add `_const` to the URL query string
      if (getConst() != null) {
        joiner.add(getConst().toUrlQueryString(prefix + "_const" + suffix));
      }
  
      // add `_enum` to the URL query string
      if (getEnum() != null) {
        for (int i = 0; i < getEnum().size(); i++) {
          if (getEnum().get(i) != null) {
            joiner.add(getEnum().get(i).toUrlQueryString(String.format("%s_enum%s%s", prefix, suffix,
                "".equals(suffix) ? "" : String.format("%s%d%s", containerPrefix, i, containerSuffix))));
          }
        }
      }
  
      // add `exclusiveMinimum` to the URL query string
      if (getExclusiveMinimum() != null) {
        joiner.add(getExclusiveMinimum().toUrlQueryString(prefix + "exclusiveMinimum" + suffix));
      }
  
      // add `exclusiveMaximum` to the URL query string
      if (getExclusiveMaximum() != null) {
        joiner.add(getExclusiveMaximum().toUrlQueryString(prefix + "exclusiveMaximum" + suffix));
      }
  
      // add `format` to the URL query string
      if (getFormat() != null) {
        try {
          joiner.add(String.format("%sformat%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getFormat()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      // add `formatMaximum` to the URL query string
      if (getFormatMaximum() != null) {
        try {
          joiner.add(String.format("%sformatMaximum%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getFormatMaximum()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      // add `formatMinimum` to the URL query string
      if (getFormatMinimum() != null) {
        try {
          joiner.add(String.format("%sformatMinimum%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getFormatMinimum()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      // add `formatExclusiveMaximum` to the URL query string
      if (getFormatExclusiveMaximum() != null) {
        try {
          joiner.add(String.format("%sformatExclusiveMaximum%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getFormatExclusiveMaximum()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      // add `formatExclusiveMinimum` to the URL query string
      if (getFormatExclusiveMinimum() != null) {
        try {
          joiner.add(String.format("%sformatExclusiveMinimum%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getFormatExclusiveMinimum()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      // add `minLength` to the URL query string
      if (getMinLength() != null) {
        try {
          joiner.add(String.format("%sminLength%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getMinLength()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      // add `maxLength` to the URL query string
      if (getMaxLength() != null) {
        try {
          joiner.add(String.format("%smaxLength%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getMaxLength()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      // add `minimum` to the URL query string
      if (getMinimum() != null) {
        joiner.add(getMinimum().toUrlQueryString(prefix + "minimum" + suffix));
      }
  
      // add `maximum` to the URL query string
      if (getMaximum() != null) {
        joiner.add(getMaximum().toUrlQueryString(prefix + "maximum" + suffix));
      }
  
      // add `not` to the URL query string
      if (getNot() != null) {
        try {
          joiner.add(String.format("%snot%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getNot()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      // add `pattern` to the URL query string
      if (getPattern() != null) {
        try {
          joiner.add(String.format("%spattern%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getPattern()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      // add `contains` to the URL query string
      if (getContains() != null) {
        joiner.add(getContains().toUrlQueryString(prefix + "contains" + suffix));
      }
  
      // add `items` to the URL query string
      if (getItems() != null) {
        joiner.add(getItems().toUrlQueryString(prefix + "items" + suffix));
      }
  
      // add `type` to the URL query string
      if (getType() != null) {
        try {
          joiner.add(String.format("%stype%s=%s", prefix, suffix, URLEncoder.encode(String.valueOf(getType()), "UTF-8").replaceAll("\\+", "%20")));
        } catch (UnsupportedEncodingException e) {
          // Should never happen, UTF-8 is always supported
          throw new RuntimeException(e);
        }
      }
  
      return joiner.toString();
    }
  
  }
  
  