Package build.buf.validate

Interface StringRulesOrBuilder

All Superinterfaces:
com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder
All Known Implementing Classes:
StringRules, StringRules.Builder
public interface StringRulesOrBuilder extends com.google.protobuf.MessageOrBuilder

  • Method Summary

    Modifier and Type
    Method
    Description
    boolean
    getAddress()
    `address` specifies that the field value must be either a valid hostname as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5) (which doesn't support internationalized domain names or IDNs) or a valid IP (v4 or v6).
    String
    getConst()
    `const` requires the field value to exactly match the specified value.
    com.google.protobuf.ByteString
    getConstBytes()
    `const` requires the field value to exactly match the specified value.
    String
    getContains()
    `contains` specifies that the field value must have the specified substring anywhere in the string.
    com.google.protobuf.ByteString
    getContainsBytes()
    `contains` specifies that the field value must have the specified substring anywhere in the string.
    boolean
    getEmail()
    `email` specifies that the field value must be a valid email address (addr-spec only) as defined by [RFC 5322](https://tools.ietf.org/html/rfc5322#section-3.4.1).
    boolean
    getHostAndPort()
    `host_and_port` specifies the field value must be a valid host and port pair.
    boolean
    getHostname()
    `hostname` specifies that the field value must be a valid hostname as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5).
    String
    getIn(int index)
    `in` specifies that the field value must be equal to one of the specified values.
    com.google.protobuf.ByteString
    getInBytes(int index)
    `in` specifies that the field value must be equal to one of the specified values.
    int
    getInCount()
    `in` specifies that the field value must be equal to one of the specified values.
    List<String>
    getInList()
    `in` specifies that the field value must be equal to one of the specified values.
    boolean
    getIp()
    `ip` specifies that the field value must be a valid IP (v4 or v6) address, without surrounding square brackets for IPv6 addresses.
    boolean
    getIpPrefix()
    `ip_prefix` specifies that the field value must be a valid IP (v4 or v6) prefix.
    boolean
    getIpv4()
    `ipv4` specifies that the field value must be a valid IPv4 address.
    boolean
    getIpv4Prefix()
    `ipv4_prefix` specifies that the field value must be a valid IPv4 prefix.
    boolean
    getIpv4WithPrefixlen()
    `ipv4_with_prefixlen` specifies that the field value must be a valid IPv4 address with prefix.
    boolean
    getIpv6()
    `ipv6` specifies that the field value must be a valid IPv6 address, without surrounding square brackets.
    boolean
    getIpv6Prefix()
    `ipv6_prefix` specifies that the field value must be a valid IPv6 prefix.
    boolean
    getIpv6WithPrefixlen()
    `ipv6_with_prefixlen` specifies that the field value must be a valid IPv6 address with prefix length.
    boolean
    getIpWithPrefixlen()
    `ip_with_prefixlen` specifies that the field value must be a valid IP (v4 or v6) address with prefix length.
    long
    getLen()
    `len` dictates that the field value must have the specified number of characters (Unicode code points), which may differ from the number of bytes in the string.
    long
    getLenBytes()
    `len_bytes` dictates that the field value must have the specified number of bytes.
    long
    getMaxBytes()
    `max_bytes` specifies that the field value must have no more than the specified number of bytes.
    long
    getMaxLen()
    `max_len` specifies that the field value must have no more than the specified number of characters (Unicode code points), which may differ from the number of bytes in the string.
    long
    getMinBytes()
    `min_bytes` specifies that the field value must have at least the specified number of bytes.
    long
    getMinLen()
    `min_len` specifies that the field value must have at least the specified number of characters (Unicode code points), which may differ from the number of bytes in the string.
    String
    getNotContains()
    `not_contains` specifies that the field value must not have the specified substring anywhere in the string.
    com.google.protobuf.ByteString
    getNotContainsBytes()
    `not_contains` specifies that the field value must not have the specified substring anywhere in the string.
    String
    getNotIn(int index)
    `not_in` specifies that the field value cannot be equal to any of the specified values.
    com.google.protobuf.ByteString
    getNotInBytes(int index)
    `not_in` specifies that the field value cannot be equal to any of the specified values.
    int
    getNotInCount()
    `not_in` specifies that the field value cannot be equal to any of the specified values.
    List<String>
    getNotInList()
    `not_in` specifies that the field value cannot be equal to any of the specified values.
    String
    getPattern()
    `pattern` specifies that the field value must match the specified regular expression (RE2 syntax), with the expression provided without any delimiters.
    com.google.protobuf.ByteString
    getPatternBytes()
    `pattern` specifies that the field value must match the specified regular expression (RE2 syntax), with the expression provided without any delimiters.
    String
    getPrefix()
    `prefix` specifies that the field value must have the specified substring at the beginning of the string.
    com.google.protobuf.ByteString
    getPrefixBytes()
    `prefix` specifies that the field value must have the specified substring at the beginning of the string.
    boolean
    getStrict()
    This applies to regexes `HTTP_HEADER_NAME` and `HTTP_HEADER_VALUE` to enable strict header validation.
    String
    getSuffix()
    `suffix` specifies that the field value must have the specified substring at the end of the string.
    com.google.protobuf.ByteString
    getSuffixBytes()
    `suffix` specifies that the field value must have the specified substring at the end of the string.
    boolean
    getUri()
    `uri` specifies that the field value must be a valid, absolute URI as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3).
    boolean
    getUriRef()
    `uri_ref` specifies that the field value must be a valid URI as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) and may be either relative or absolute.
    boolean
    getUuid()
    `uuid` specifies that the field value must be a valid UUID as defined by [RFC 4122](https://tools.ietf.org/html/rfc4122#section-4.1.2).
    StringRules.WellKnownCase
    getWellKnownCase()
     
    KnownRegex
    getWellKnownRegex()
    `well_known_regex` specifies a common well-known pattern defined as a regex.
    int
    getWellKnownRegexValue()
    `well_known_regex` specifies a common well-known pattern defined as a regex.
    boolean
    hasAddress()
    `address` specifies that the field value must be either a valid hostname as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5) (which doesn't support internationalized domain names or IDNs) or a valid IP (v4 or v6).
    boolean
    hasConst()
    `const` requires the field value to exactly match the specified value.
    boolean
    hasContains()
    `contains` specifies that the field value must have the specified substring anywhere in the string.
    boolean
    hasEmail()
    `email` specifies that the field value must be a valid email address (addr-spec only) as defined by [RFC 5322](https://tools.ietf.org/html/rfc5322#section-3.4.1).
    boolean
    hasHostAndPort()
    `host_and_port` specifies the field value must be a valid host and port pair.
    boolean
    hasHostname()
    `hostname` specifies that the field value must be a valid hostname as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5).
    boolean
    hasIp()
    `ip` specifies that the field value must be a valid IP (v4 or v6) address, without surrounding square brackets for IPv6 addresses.
    boolean
    hasIpPrefix()
    `ip_prefix` specifies that the field value must be a valid IP (v4 or v6) prefix.
    boolean
    hasIpv4()
    `ipv4` specifies that the field value must be a valid IPv4 address.
    boolean
    hasIpv4Prefix()
    `ipv4_prefix` specifies that the field value must be a valid IPv4 prefix.
    boolean
    hasIpv4WithPrefixlen()
    `ipv4_with_prefixlen` specifies that the field value must be a valid IPv4 address with prefix.
    boolean
    hasIpv6()
    `ipv6` specifies that the field value must be a valid IPv6 address, without surrounding square brackets.
    boolean
    hasIpv6Prefix()
    `ipv6_prefix` specifies that the field value must be a valid IPv6 prefix.
    boolean
    hasIpv6WithPrefixlen()
    `ipv6_with_prefixlen` specifies that the field value must be a valid IPv6 address with prefix length.
    boolean
    hasIpWithPrefixlen()
    `ip_with_prefixlen` specifies that the field value must be a valid IP (v4 or v6) address with prefix length.
    boolean
    hasLen()
    `len` dictates that the field value must have the specified number of characters (Unicode code points), which may differ from the number of bytes in the string.
    boolean
    hasLenBytes()
    `len_bytes` dictates that the field value must have the specified number of bytes.
    boolean
    hasMaxBytes()
    `max_bytes` specifies that the field value must have no more than the specified number of bytes.
    boolean
    hasMaxLen()
    `max_len` specifies that the field value must have no more than the specified number of characters (Unicode code points), which may differ from the number of bytes in the string.
    boolean
    hasMinBytes()
    `min_bytes` specifies that the field value must have at least the specified number of bytes.
    boolean
    hasMinLen()
    `min_len` specifies that the field value must have at least the specified number of characters (Unicode code points), which may differ from the number of bytes in the string.
    boolean
    hasNotContains()
    `not_contains` specifies that the field value must not have the specified substring anywhere in the string.
    boolean
    hasPattern()
    `pattern` specifies that the field value must match the specified regular expression (RE2 syntax), with the expression provided without any delimiters.
    boolean
    hasPrefix()
    `prefix` specifies that the field value must have the specified substring at the beginning of the string.
    boolean
    hasStrict()
    This applies to regexes `HTTP_HEADER_NAME` and `HTTP_HEADER_VALUE` to enable strict header validation.
    boolean
    hasSuffix()
    `suffix` specifies that the field value must have the specified substring at the end of the string.
    boolean
    hasUri()
    `uri` specifies that the field value must be a valid, absolute URI as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3).
    boolean
    hasUriRef()
    `uri_ref` specifies that the field value must be a valid URI as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) and may be either relative or absolute.
    boolean
    hasUuid()
    `uuid` specifies that the field value must be a valid UUID as defined by [RFC 4122](https://tools.ietf.org/html/rfc4122#section-4.1.2).
    boolean
    hasWellKnownRegex()
    `well_known_regex` specifies a common well-known pattern defined as a regex.

    Methods inherited from interface com.google.protobuf.MessageLiteOrBuilder

    isInitialized

    Methods inherited from interface com.google.protobuf.MessageOrBuilder

    findInitializationErrors, getAllFields, getDefaultInstanceForType, getDescriptorForType, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof

  • Method Details

    • hasConst

      boolean hasConst()
       `const` requires the field value to exactly match the specified value. If
 the field value doesn't match, an error message is generated.

 ```proto
 message MyString {
   // value must equal `hello`
   string value = 1 [(buf.validate.field).string.const = "hello"];
 }
 ```
      optional string const = 1 [json_name = "const", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the const field is set.

    • getConst

      String getConst()
       `const` requires the field value to exactly match the specified value. If
 the field value doesn't match, an error message is generated.

 ```proto
 message MyString {
   // value must equal `hello`
   string value = 1 [(buf.validate.field).string.const = "hello"];
 }
 ```
      optional string const = 1 [json_name = "const", (.buf.validate.priv.field) = { ... }
      Returns:
      The const.

    • getConstBytes

      com.google.protobuf.ByteString getConstBytes()
       `const` requires the field value to exactly match the specified value. If
 the field value doesn't match, an error message is generated.

 ```proto
 message MyString {
   // value must equal `hello`
   string value = 1 [(buf.validate.field).string.const = "hello"];
 }
 ```
      optional string const = 1 [json_name = "const", (.buf.validate.priv.field) = { ... }
      Returns:
      The bytes for const.

    • hasLen

      boolean hasLen()
       `len` dictates that the field value must have the specified
 number of characters (Unicode code points), which may differ from the number
 of bytes in the string. If the field value does not meet the specified
 length, an error message will be generated.

 ```proto
 message MyString {
   // value length must be 5 characters
   string value = 1 [(buf.validate.field).string.len = 5];
 }
 ```
      optional uint64 len = 19 [json_name = "len", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the len field is set.

    • getLen

      long getLen()
       `len` dictates that the field value must have the specified
 number of characters (Unicode code points), which may differ from the number
 of bytes in the string. If the field value does not meet the specified
 length, an error message will be generated.

 ```proto
 message MyString {
   // value length must be 5 characters
   string value = 1 [(buf.validate.field).string.len = 5];
 }
 ```
      optional uint64 len = 19 [json_name = "len", (.buf.validate.priv.field) = { ... }
      Returns:
      The len.

    • hasMinLen

      boolean hasMinLen()
       `min_len` specifies that the field value must have at least the specified
 number of characters (Unicode code points), which may differ from the number
 of bytes in the string. If the field value contains fewer characters, an error
 message will be generated.

 ```proto
 message MyString {
   // value length must be at least 3 characters
   string value = 1 [(buf.validate.field).string.min_len = 3];
 }
 ```
      optional uint64 min_len = 2 [json_name = "minLen", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the minLen field is set.

    • getMinLen

      long getMinLen()
       `min_len` specifies that the field value must have at least the specified
 number of characters (Unicode code points), which may differ from the number
 of bytes in the string. If the field value contains fewer characters, an error
 message will be generated.

 ```proto
 message MyString {
   // value length must be at least 3 characters
   string value = 1 [(buf.validate.field).string.min_len = 3];
 }
 ```
      optional uint64 min_len = 2 [json_name = "minLen", (.buf.validate.priv.field) = { ... }
      Returns:
      The minLen.

    • hasMaxLen

      boolean hasMaxLen()
       `max_len` specifies that the field value must have no more than the specified
 number of characters (Unicode code points), which may differ from the
 number of bytes in the string. If the field value contains more characters,
 an error message will be generated.

 ```proto
 message MyString {
   // value length must be at most 10 characters
   string value = 1 [(buf.validate.field).string.max_len = 10];
 }
 ```
      optional uint64 max_len = 3 [json_name = "maxLen", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the maxLen field is set.

    • getMaxLen

      long getMaxLen()
       `max_len` specifies that the field value must have no more than the specified
 number of characters (Unicode code points), which may differ from the
 number of bytes in the string. If the field value contains more characters,
 an error message will be generated.

 ```proto
 message MyString {
   // value length must be at most 10 characters
   string value = 1 [(buf.validate.field).string.max_len = 10];
 }
 ```
      optional uint64 max_len = 3 [json_name = "maxLen", (.buf.validate.priv.field) = { ... }
      Returns:
      The maxLen.

    • hasLenBytes

      boolean hasLenBytes()
       `len_bytes` dictates that the field value must have the specified number of
 bytes. If the field value does not match the specified length in bytes,
 an error message will be generated.

 ```proto
 message MyString {
   // value length must be 6 bytes
   string value = 1 [(buf.validate.field).string.len_bytes = 6];
 }
 ```
      optional uint64 len_bytes = 20 [json_name = "lenBytes", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the lenBytes field is set.

    • getLenBytes

      long getLenBytes()
       `len_bytes` dictates that the field value must have the specified number of
 bytes. If the field value does not match the specified length in bytes,
 an error message will be generated.

 ```proto
 message MyString {
   // value length must be 6 bytes
   string value = 1 [(buf.validate.field).string.len_bytes = 6];
 }
 ```
      optional uint64 len_bytes = 20 [json_name = "lenBytes", (.buf.validate.priv.field) = { ... }
      Returns:
      The lenBytes.

    • hasMinBytes

      boolean hasMinBytes()
       `min_bytes` specifies that the field value must have at least the specified
 number of bytes. If the field value contains fewer bytes, an error message
 will be generated.

 ```proto
 message MyString {
   // value length must be at least 4 bytes
   string value = 1 [(buf.validate.field).string.min_bytes = 4];
 }

 ```
      optional uint64 min_bytes = 4 [json_name = "minBytes", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the minBytes field is set.

    • getMinBytes

      long getMinBytes()
       `min_bytes` specifies that the field value must have at least the specified
 number of bytes. If the field value contains fewer bytes, an error message
 will be generated.

 ```proto
 message MyString {
   // value length must be at least 4 bytes
   string value = 1 [(buf.validate.field).string.min_bytes = 4];
 }

 ```
      optional uint64 min_bytes = 4 [json_name = "minBytes", (.buf.validate.priv.field) = { ... }
      Returns:
      The minBytes.

    • hasMaxBytes

      boolean hasMaxBytes()
       `max_bytes` specifies that the field value must have no more than the
specified number of bytes. If the field value contains more bytes, an
 error message will be generated.

 ```proto
 message MyString {
   // value length must be at most 8 bytes
   string value = 1 [(buf.validate.field).string.max_bytes = 8];
 }
 ```
      optional uint64 max_bytes = 5 [json_name = "maxBytes", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the maxBytes field is set.

    • getMaxBytes

      long getMaxBytes()
       `max_bytes` specifies that the field value must have no more than the
specified number of bytes. If the field value contains more bytes, an
 error message will be generated.

 ```proto
 message MyString {
   // value length must be at most 8 bytes
   string value = 1 [(buf.validate.field).string.max_bytes = 8];
 }
 ```
      optional uint64 max_bytes = 5 [json_name = "maxBytes", (.buf.validate.priv.field) = { ... }
      Returns:
      The maxBytes.

    • hasPattern

      boolean hasPattern()
       `pattern` specifies that the field value must match the specified
 regular expression (RE2 syntax), with the expression provided without any
 delimiters. If the field value doesn't match the regular expression, an
 error message will be generated.

 ```proto
 message MyString {
   // value does not match regex pattern `^[a-zA-Z]//$`
   string value = 1 [(buf.validate.field).string.pattern = "^[a-zA-Z]//$"];
 }
 ```
      optional string pattern = 6 [json_name = "pattern", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the pattern field is set.

    • getPattern

      String getPattern()
       `pattern` specifies that the field value must match the specified
 regular expression (RE2 syntax), with the expression provided without any
 delimiters. If the field value doesn't match the regular expression, an
 error message will be generated.

 ```proto
 message MyString {
   // value does not match regex pattern `^[a-zA-Z]//$`
   string value = 1 [(buf.validate.field).string.pattern = "^[a-zA-Z]//$"];
 }
 ```
      optional string pattern = 6 [json_name = "pattern", (.buf.validate.priv.field) = { ... }
      Returns:
      The pattern.

    • getPatternBytes

      com.google.protobuf.ByteString getPatternBytes()
       `pattern` specifies that the field value must match the specified
 regular expression (RE2 syntax), with the expression provided without any
 delimiters. If the field value doesn't match the regular expression, an
 error message will be generated.

 ```proto
 message MyString {
   // value does not match regex pattern `^[a-zA-Z]//$`
   string value = 1 [(buf.validate.field).string.pattern = "^[a-zA-Z]//$"];
 }
 ```
      optional string pattern = 6 [json_name = "pattern", (.buf.validate.priv.field) = { ... }
      Returns:
      The bytes for pattern.

    • hasPrefix

      boolean hasPrefix()
       `prefix` specifies that the field value must have the
specified substring at the beginning of the string. If the field value
 doesn't start with the specified prefix, an error message will be
 generated.

 ```proto
 message MyString {
   // value does not have prefix `pre`
   string value = 1 [(buf.validate.field).string.prefix = "pre"];
 }
 ```
      optional string prefix = 7 [json_name = "prefix", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the prefix field is set.

    • getPrefix

      String getPrefix()
       `prefix` specifies that the field value must have the
specified substring at the beginning of the string. If the field value
 doesn't start with the specified prefix, an error message will be
 generated.

 ```proto
 message MyString {
   // value does not have prefix `pre`
   string value = 1 [(buf.validate.field).string.prefix = "pre"];
 }
 ```
      optional string prefix = 7 [json_name = "prefix", (.buf.validate.priv.field) = { ... }
      Returns:
      The prefix.

    • getPrefixBytes

      com.google.protobuf.ByteString getPrefixBytes()
       `prefix` specifies that the field value must have the
specified substring at the beginning of the string. If the field value
 doesn't start with the specified prefix, an error message will be
 generated.

 ```proto
 message MyString {
   // value does not have prefix `pre`
   string value = 1 [(buf.validate.field).string.prefix = "pre"];
 }
 ```
      optional string prefix = 7 [json_name = "prefix", (.buf.validate.priv.field) = { ... }
      Returns:
      The bytes for prefix.

    • hasSuffix

      boolean hasSuffix()
       `suffix` specifies that the field value must have the
specified substring at the end of the string. If the field value doesn't
 end with the specified suffix, an error message will be generated.

 ```proto
 message MyString {
   // value does not have suffix `post`
   string value = 1 [(buf.validate.field).string.suffix = "post"];
 }
 ```
      optional string suffix = 8 [json_name = "suffix", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the suffix field is set.

    • getSuffix

      String getSuffix()
       `suffix` specifies that the field value must have the
specified substring at the end of the string. If the field value doesn't
 end with the specified suffix, an error message will be generated.

 ```proto
 message MyString {
   // value does not have suffix `post`
   string value = 1 [(buf.validate.field).string.suffix = "post"];
 }
 ```
      optional string suffix = 8 [json_name = "suffix", (.buf.validate.priv.field) = { ... }
      Returns:
      The suffix.

    • getSuffixBytes

      com.google.protobuf.ByteString getSuffixBytes()
       `suffix` specifies that the field value must have the
specified substring at the end of the string. If the field value doesn't
 end with the specified suffix, an error message will be generated.

 ```proto
 message MyString {
   // value does not have suffix `post`
   string value = 1 [(buf.validate.field).string.suffix = "post"];
 }
 ```
      optional string suffix = 8 [json_name = "suffix", (.buf.validate.priv.field) = { ... }
      Returns:
      The bytes for suffix.

    • hasContains

      boolean hasContains()
       `contains` specifies that the field value must have the
specified substring anywhere in the string. If the field value doesn't
 contain the specified substring, an error message will be generated.

 ```proto
 message MyString {
   // value does not contain substring `inside`.
   string value = 1 [(buf.validate.field).string.contains = "inside"];
 }
 ```
      optional string contains = 9 [json_name = "contains", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the contains field is set.

    • getContains

      String getContains()
       `contains` specifies that the field value must have the
specified substring anywhere in the string. If the field value doesn't
 contain the specified substring, an error message will be generated.

 ```proto
 message MyString {
   // value does not contain substring `inside`.
   string value = 1 [(buf.validate.field).string.contains = "inside"];
 }
 ```
      optional string contains = 9 [json_name = "contains", (.buf.validate.priv.field) = { ... }
      Returns:
      The contains.

    • getContainsBytes

      com.google.protobuf.ByteString getContainsBytes()
       `contains` specifies that the field value must have the
specified substring anywhere in the string. If the field value doesn't
 contain the specified substring, an error message will be generated.

 ```proto
 message MyString {
   // value does not contain substring `inside`.
   string value = 1 [(buf.validate.field).string.contains = "inside"];
 }
 ```
      optional string contains = 9 [json_name = "contains", (.buf.validate.priv.field) = { ... }
      Returns:
      The bytes for contains.

    • hasNotContains

      boolean hasNotContains()
       `not_contains` specifies that the field value must not have the
specified substring anywhere in the string. If the field value contains
 the specified substring, an error message will be generated.

 ```proto
 message MyString {
   // value contains substring `inside`.
   string value = 1 [(buf.validate.field).string.not_contains = "inside"];
 }
 ```
      optional string not_contains = 23 [json_name = "notContains", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the notContains field is set.

    • getNotContains

      String getNotContains()
       `not_contains` specifies that the field value must not have the
specified substring anywhere in the string. If the field value contains
 the specified substring, an error message will be generated.

 ```proto
 message MyString {
   // value contains substring `inside`.
   string value = 1 [(buf.validate.field).string.not_contains = "inside"];
 }
 ```
      optional string not_contains = 23 [json_name = "notContains", (.buf.validate.priv.field) = { ... }
      Returns:
      The notContains.

    • getNotContainsBytes

      com.google.protobuf.ByteString getNotContainsBytes()
       `not_contains` specifies that the field value must not have the
specified substring anywhere in the string. If the field value contains
 the specified substring, an error message will be generated.

 ```proto
 message MyString {
   // value contains substring `inside`.
   string value = 1 [(buf.validate.field).string.not_contains = "inside"];
 }
 ```
      optional string not_contains = 23 [json_name = "notContains", (.buf.validate.priv.field) = { ... }
      Returns:
      The bytes for notContains.

    • getInList

      List<String> getInList()
       `in` specifies that the field value must be equal to one of the specified
 values. If the field value isn't one of the specified values, an error
 message will be generated.

 ```proto
 message MyString {
   // value must be in list ["apple", "banana"]
   repeated string value = 1 [(buf.validate.field).string.in = "apple", (buf.validate.field).string.in = "banana"];
 }
 ```
      repeated string in = 10 [json_name = "in", (.buf.validate.priv.field) = { ... }
      Returns:
      A list containing the in.

    • getInCount

      int getInCount()
       `in` specifies that the field value must be equal to one of the specified
 values. If the field value isn't one of the specified values, an error
 message will be generated.

 ```proto
 message MyString {
   // value must be in list ["apple", "banana"]
   repeated string value = 1 [(buf.validate.field).string.in = "apple", (buf.validate.field).string.in = "banana"];
 }
 ```
      repeated string in = 10 [json_name = "in", (.buf.validate.priv.field) = { ... }
      Returns:
      The count of in.

    • getIn

      String getIn(int index)
       `in` specifies that the field value must be equal to one of the specified
 values. If the field value isn't one of the specified values, an error
 message will be generated.

 ```proto
 message MyString {
   // value must be in list ["apple", "banana"]
   repeated string value = 1 [(buf.validate.field).string.in = "apple", (buf.validate.field).string.in = "banana"];
 }
 ```
      repeated string in = 10 [json_name = "in", (.buf.validate.priv.field) = { ... }
      Parameters:
      index - The index of the element to return.
      Returns:
      The in at the given index.

    • getInBytes

      com.google.protobuf.ByteString getInBytes(int index)
       `in` specifies that the field value must be equal to one of the specified
 values. If the field value isn't one of the specified values, an error
 message will be generated.

 ```proto
 message MyString {
   // value must be in list ["apple", "banana"]
   repeated string value = 1 [(buf.validate.field).string.in = "apple", (buf.validate.field).string.in = "banana"];
 }
 ```
      repeated string in = 10 [json_name = "in", (.buf.validate.priv.field) = { ... }
      Parameters:
      index - The index of the value to return.
      Returns:
      The bytes of the in at the given index.

    • getNotInList

      List<String> getNotInList()
       `not_in` specifies that the field value cannot be equal to any
 of the specified values. If the field value is one of the specified values,
 an error message will be generated.
 ```proto
 message MyString {
   // value must not be in list ["orange", "grape"]
   repeated string value = 1 [(buf.validate.field).string.not_in = "orange", (buf.validate.field).string.not_in = "grape"];
 }
 ```
      repeated string not_in = 11 [json_name = "notIn", (.buf.validate.priv.field) = { ... }
      Returns:
      A list containing the notIn.

    • getNotInCount

      int getNotInCount()
       `not_in` specifies that the field value cannot be equal to any
 of the specified values. If the field value is one of the specified values,
 an error message will be generated.
 ```proto
 message MyString {
   // value must not be in list ["orange", "grape"]
   repeated string value = 1 [(buf.validate.field).string.not_in = "orange", (buf.validate.field).string.not_in = "grape"];
 }
 ```
      repeated string not_in = 11 [json_name = "notIn", (.buf.validate.priv.field) = { ... }
      Returns:
      The count of notIn.

    • getNotIn

      String getNotIn(int index)
       `not_in` specifies that the field value cannot be equal to any
 of the specified values. If the field value is one of the specified values,
 an error message will be generated.
 ```proto
 message MyString {
   // value must not be in list ["orange", "grape"]
   repeated string value = 1 [(buf.validate.field).string.not_in = "orange", (buf.validate.field).string.not_in = "grape"];
 }
 ```
      repeated string not_in = 11 [json_name = "notIn", (.buf.validate.priv.field) = { ... }
      Parameters:
      index - The index of the element to return.
      Returns:
      The notIn at the given index.

    • getNotInBytes

      com.google.protobuf.ByteString getNotInBytes(int index)
       `not_in` specifies that the field value cannot be equal to any
 of the specified values. If the field value is one of the specified values,
 an error message will be generated.
 ```proto
 message MyString {
   // value must not be in list ["orange", "grape"]
   repeated string value = 1 [(buf.validate.field).string.not_in = "orange", (buf.validate.field).string.not_in = "grape"];
 }
 ```
      repeated string not_in = 11 [json_name = "notIn", (.buf.validate.priv.field) = { ... }
      Parameters:
      index - The index of the value to return.
      Returns:
      The bytes of the notIn at the given index.

    • hasEmail

      boolean hasEmail()
       `email` specifies that the field value must be a valid email address
 (addr-spec only) as defined by [RFC 5322](https://tools.ietf.org/html/rfc5322#section-3.4.1).
 If the field value isn't a valid email address, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid email address
   string value = 1 [(buf.validate.field).string.email = true];
 }
 ```
      bool email = 12 [json_name = "email", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the email field is set.

    • getEmail

      boolean getEmail()
       `email` specifies that the field value must be a valid email address
 (addr-spec only) as defined by [RFC 5322](https://tools.ietf.org/html/rfc5322#section-3.4.1).
 If the field value isn't a valid email address, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid email address
   string value = 1 [(buf.validate.field).string.email = true];
 }
 ```
      bool email = 12 [json_name = "email", (.buf.validate.priv.field) = { ... }
      Returns:
      The email.

    • hasHostname

      boolean hasHostname()
       `hostname` specifies that the field value must be a valid
 hostname as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5). This constraint doesn't support
 internationalized domain names (IDNs). If the field value isn't a
 valid hostname, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid hostname
   string value = 1 [(buf.validate.field).string.hostname = true];
 }
 ```
      bool hostname = 13 [json_name = "hostname", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the hostname field is set.

    • getHostname

      boolean getHostname()
       `hostname` specifies that the field value must be a valid
 hostname as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5). This constraint doesn't support
 internationalized domain names (IDNs). If the field value isn't a
 valid hostname, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid hostname
   string value = 1 [(buf.validate.field).string.hostname = true];
 }
 ```
      bool hostname = 13 [json_name = "hostname", (.buf.validate.priv.field) = { ... }
      Returns:
      The hostname.

    • hasIp

      boolean hasIp()
       `ip` specifies that the field value must be a valid IP
 (v4 or v6) address, without surrounding square brackets for IPv6 addresses.
 If the field value isn't a valid IP address, an error message will be
 generated.

 ```proto
 message MyString {
   // value must be a valid IP address
   string value = 1 [(buf.validate.field).string.ip = true];
 }
 ```
      bool ip = 14 [json_name = "ip", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the ip field is set.

    • getIp

      boolean getIp()
       `ip` specifies that the field value must be a valid IP
 (v4 or v6) address, without surrounding square brackets for IPv6 addresses.
 If the field value isn't a valid IP address, an error message will be
 generated.

 ```proto
 message MyString {
   // value must be a valid IP address
   string value = 1 [(buf.validate.field).string.ip = true];
 }
 ```
      bool ip = 14 [json_name = "ip", (.buf.validate.priv.field) = { ... }
      Returns:
      The ip.

    • hasIpv4

      boolean hasIpv4()
       `ipv4` specifies that the field value must be a valid IPv4
 address. If the field value isn't a valid IPv4 address, an error message
 will be generated.

 ```proto
 message MyString {
   // value must be a valid IPv4 address
   string value = 1 [(buf.validate.field).string.ipv4 = true];
 }
 ```
      bool ipv4 = 15 [json_name = "ipv4", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the ipv4 field is set.

    • getIpv4

      boolean getIpv4()
       `ipv4` specifies that the field value must be a valid IPv4
 address. If the field value isn't a valid IPv4 address, an error message
 will be generated.

 ```proto
 message MyString {
   // value must be a valid IPv4 address
   string value = 1 [(buf.validate.field).string.ipv4 = true];
 }
 ```
      bool ipv4 = 15 [json_name = "ipv4", (.buf.validate.priv.field) = { ... }
      Returns:
      The ipv4.

    • hasIpv6

      boolean hasIpv6()
       `ipv6` specifies that the field value must be a valid
 IPv6 address, without surrounding square brackets. If the field value is
 not a valid IPv6 address, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid IPv6 address
   string value = 1 [(buf.validate.field).string.ipv6 = true];
 }
 ```
      bool ipv6 = 16 [json_name = "ipv6", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the ipv6 field is set.

    • getIpv6

      boolean getIpv6()
       `ipv6` specifies that the field value must be a valid
 IPv6 address, without surrounding square brackets. If the field value is
 not a valid IPv6 address, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid IPv6 address
   string value = 1 [(buf.validate.field).string.ipv6 = true];
 }
 ```
      bool ipv6 = 16 [json_name = "ipv6", (.buf.validate.priv.field) = { ... }
      Returns:
      The ipv6.

    • hasUri

      boolean hasUri()
       `uri` specifies that the field value must be a valid,
 absolute URI as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3). If the field value isn't a valid,
 absolute URI, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid URI
   string value = 1 [(buf.validate.field).string.uri = true];
 }
 ```
      bool uri = 17 [json_name = "uri", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the uri field is set.

    • getUri

      boolean getUri()
       `uri` specifies that the field value must be a valid,
 absolute URI as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3). If the field value isn't a valid,
 absolute URI, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid URI
   string value = 1 [(buf.validate.field).string.uri = true];
 }
 ```
      bool uri = 17 [json_name = "uri", (.buf.validate.priv.field) = { ... }
      Returns:
      The uri.

    • hasUriRef

      boolean hasUriRef()
       `uri_ref` specifies that the field value must be a valid URI
 as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) and may be either relative or absolute. If the
 field value isn't a valid URI, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid URI
   string value = 1 [(buf.validate.field).string.uri_ref = true];
 }
 ```
      bool uri_ref = 18 [json_name = "uriRef", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the uriRef field is set.

    • getUriRef

      boolean getUriRef()
       `uri_ref` specifies that the field value must be a valid URI
 as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) and may be either relative or absolute. If the
 field value isn't a valid URI, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid URI
   string value = 1 [(buf.validate.field).string.uri_ref = true];
 }
 ```
      bool uri_ref = 18 [json_name = "uriRef", (.buf.validate.priv.field) = { ... }
      Returns:
      The uriRef.

    • hasAddress

      boolean hasAddress()
       `address` specifies that the field value must be either a valid hostname
 as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5)
 (which doesn't support internationalized domain names or IDNs) or a valid
 IP (v4 or v6). If the field value isn't a valid hostname or IP, an error
 message will be generated.

 ```proto
 message MyString {
   // value must be a valid hostname, or ip address
   string value = 1 [(buf.validate.field).string.address = true];
 }
 ```
      bool address = 21 [json_name = "address", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the address field is set.

    • getAddress

      boolean getAddress()
       `address` specifies that the field value must be either a valid hostname
 as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5)
 (which doesn't support internationalized domain names or IDNs) or a valid
 IP (v4 or v6). If the field value isn't a valid hostname or IP, an error
 message will be generated.

 ```proto
 message MyString {
   // value must be a valid hostname, or ip address
   string value = 1 [(buf.validate.field).string.address = true];
 }
 ```
      bool address = 21 [json_name = "address", (.buf.validate.priv.field) = { ... }
      Returns:
      The address.

    • hasUuid

      boolean hasUuid()
       `uuid` specifies that the field value must be a valid UUID as defined by
 [RFC 4122](https://tools.ietf.org/html/rfc4122#section-4.1.2). If the
 field value isn't a valid UUID, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid UUID
   string value = 1 [(buf.validate.field).string.uuid = true];
 }
 ```
      bool uuid = 22 [json_name = "uuid", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the uuid field is set.

    • getUuid

      boolean getUuid()
       `uuid` specifies that the field value must be a valid UUID as defined by
 [RFC 4122](https://tools.ietf.org/html/rfc4122#section-4.1.2). If the
 field value isn't a valid UUID, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid UUID
   string value = 1 [(buf.validate.field).string.uuid = true];
 }
 ```
      bool uuid = 22 [json_name = "uuid", (.buf.validate.priv.field) = { ... }
      Returns:
      The uuid.

    • hasIpWithPrefixlen

      boolean hasIpWithPrefixlen()
       `ip_with_prefixlen` specifies that the field value must be a valid IP (v4 or v6)
 address with prefix length. If the field value isn't a valid IP with prefix
 length, an error message will be generated.


 ```proto
 message MyString {
   // value must be a valid IP with prefix length
    string value = 1 [(buf.validate.field).string.ip_with_prefixlen = true];
 }
 ```
      bool ip_with_prefixlen = 26 [json_name = "ipWithPrefixlen", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the ipWithPrefixlen field is set.

    • getIpWithPrefixlen

      boolean getIpWithPrefixlen()
       `ip_with_prefixlen` specifies that the field value must be a valid IP (v4 or v6)
 address with prefix length. If the field value isn't a valid IP with prefix
 length, an error message will be generated.


 ```proto
 message MyString {
   // value must be a valid IP with prefix length
    string value = 1 [(buf.validate.field).string.ip_with_prefixlen = true];
 }
 ```
      bool ip_with_prefixlen = 26 [json_name = "ipWithPrefixlen", (.buf.validate.priv.field) = { ... }
      Returns:
      The ipWithPrefixlen.

    • hasIpv4WithPrefixlen

      boolean hasIpv4WithPrefixlen()
       `ipv4_with_prefixlen` specifies that the field value must be a valid
 IPv4 address with prefix.
 If the field value isn't a valid IPv4 address with prefix length,
 an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid IPv4 address with prefix length
    string value = 1 [(buf.validate.field).string.ipv4_with_prefixlen = true];
 }
 ```
      bool ipv4_with_prefixlen = 27 [json_name = "ipv4WithPrefixlen", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the ipv4WithPrefixlen field is set.

    • getIpv4WithPrefixlen

      boolean getIpv4WithPrefixlen()
       `ipv4_with_prefixlen` specifies that the field value must be a valid
 IPv4 address with prefix.
 If the field value isn't a valid IPv4 address with prefix length,
 an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid IPv4 address with prefix length
    string value = 1 [(buf.validate.field).string.ipv4_with_prefixlen = true];
 }
 ```
      bool ipv4_with_prefixlen = 27 [json_name = "ipv4WithPrefixlen", (.buf.validate.priv.field) = { ... }
      Returns:
      The ipv4WithPrefixlen.

    • hasIpv6WithPrefixlen

      boolean hasIpv6WithPrefixlen()
       `ipv6_with_prefixlen` specifies that the field value must be a valid
 IPv6 address with prefix length.
 If the field value is not a valid IPv6 address with prefix length,
 an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid IPv6 address prefix length
    string value = 1 [(buf.validate.field).string.ipv6_with_prefixlen = true];
 }
 ```
      bool ipv6_with_prefixlen = 28 [json_name = "ipv6WithPrefixlen", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the ipv6WithPrefixlen field is set.

    • getIpv6WithPrefixlen

      boolean getIpv6WithPrefixlen()
       `ipv6_with_prefixlen` specifies that the field value must be a valid
 IPv6 address with prefix length.
 If the field value is not a valid IPv6 address with prefix length,
 an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid IPv6 address prefix length
    string value = 1 [(buf.validate.field).string.ipv6_with_prefixlen = true];
 }
 ```
      bool ipv6_with_prefixlen = 28 [json_name = "ipv6WithPrefixlen", (.buf.validate.priv.field) = { ... }
      Returns:
      The ipv6WithPrefixlen.

    • hasIpPrefix

      boolean hasIpPrefix()
       `ip_prefix` specifies that the field value must be a valid IP (v4 or v6) prefix.
 If the field value isn't a valid IP prefix, an error message will be
 generated. The prefix must have all zeros for the masked bits of the prefix (e.g.,
 `127.0.0.0/16`, not `127.0.0.1/16`).

 ```proto
 message MyString {
   // value must be a valid IP prefix
    string value = 1 [(buf.validate.field).string.ip_prefix = true];
 }
 ```
      bool ip_prefix = 29 [json_name = "ipPrefix", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the ipPrefix field is set.

    • getIpPrefix

      boolean getIpPrefix()
       `ip_prefix` specifies that the field value must be a valid IP (v4 or v6) prefix.
 If the field value isn't a valid IP prefix, an error message will be
 generated. The prefix must have all zeros for the masked bits of the prefix (e.g.,
 `127.0.0.0/16`, not `127.0.0.1/16`).

 ```proto
 message MyString {
   // value must be a valid IP prefix
    string value = 1 [(buf.validate.field).string.ip_prefix = true];
 }
 ```
      bool ip_prefix = 29 [json_name = "ipPrefix", (.buf.validate.priv.field) = { ... }
      Returns:
      The ipPrefix.

    • hasIpv4Prefix

      boolean hasIpv4Prefix()
       `ipv4_prefix` specifies that the field value must be a valid IPv4
 prefix. If the field value isn't a valid IPv4 prefix, an error message
 will be generated. The prefix must have all zeros for the masked bits of
 the prefix (e.g., `127.0.0.0/16`, not `127.0.0.1/16`).

 ```proto
 message MyString {
   // value must be a valid IPv4 prefix
    string value = 1 [(buf.validate.field).string.ipv4_prefix = true];
 }
 ```
      bool ipv4_prefix = 30 [json_name = "ipv4Prefix", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the ipv4Prefix field is set.

    • getIpv4Prefix

      boolean getIpv4Prefix()
       `ipv4_prefix` specifies that the field value must be a valid IPv4
 prefix. If the field value isn't a valid IPv4 prefix, an error message
 will be generated. The prefix must have all zeros for the masked bits of
 the prefix (e.g., `127.0.0.0/16`, not `127.0.0.1/16`).

 ```proto
 message MyString {
   // value must be a valid IPv4 prefix
    string value = 1 [(buf.validate.field).string.ipv4_prefix = true];
 }
 ```
      bool ipv4_prefix = 30 [json_name = "ipv4Prefix", (.buf.validate.priv.field) = { ... }
      Returns:
      The ipv4Prefix.

    • hasIpv6Prefix

      boolean hasIpv6Prefix()
       `ipv6_prefix` specifies that the field value must be a valid IPv6 prefix.
 If the field value is not a valid IPv6 prefix, an error message will be
 generated. The prefix must have all zeros for the masked bits of the prefix
 (e.g., `2001:db8::/48`, not `2001:db8::1/48`).

 ```proto
 message MyString {
   // value must be a valid IPv6 prefix
    string value = 1 [(buf.validate.field).string.ipv6_prefix = true];
 }
 ```
      bool ipv6_prefix = 31 [json_name = "ipv6Prefix", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the ipv6Prefix field is set.

    • getIpv6Prefix

      boolean getIpv6Prefix()
       `ipv6_prefix` specifies that the field value must be a valid IPv6 prefix.
 If the field value is not a valid IPv6 prefix, an error message will be
 generated. The prefix must have all zeros for the masked bits of the prefix
 (e.g., `2001:db8::/48`, not `2001:db8::1/48`).

 ```proto
 message MyString {
   // value must be a valid IPv6 prefix
    string value = 1 [(buf.validate.field).string.ipv6_prefix = true];
 }
 ```
      bool ipv6_prefix = 31 [json_name = "ipv6Prefix", (.buf.validate.priv.field) = { ... }
      Returns:
      The ipv6Prefix.

    • hasHostAndPort

      boolean hasHostAndPort()
       `host_and_port` specifies the field value must be a valid host and port
 pair. The host must be a valid hostname or IP address while the port
 must be in the range of 0-65535, inclusive. IPv6 addresses must be delimited
 with square brackets (e.g., `[::1]:1234`).
      bool host_and_port = 32 [json_name = "hostAndPort", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the hostAndPort field is set.

    • getHostAndPort

      boolean getHostAndPort()
       `host_and_port` specifies the field value must be a valid host and port
 pair. The host must be a valid hostname or IP address while the port
 must be in the range of 0-65535, inclusive. IPv6 addresses must be delimited
 with square brackets (e.g., `[::1]:1234`).
      bool host_and_port = 32 [json_name = "hostAndPort", (.buf.validate.priv.field) = { ... }
      Returns:
      The hostAndPort.

    • hasWellKnownRegex

      boolean hasWellKnownRegex()
       `well_known_regex` specifies a common well-known pattern
 defined as a regex. If the field value doesn't match the well-known
 regex, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid HTTP header value
   string value = 1 [(buf.validate.field).string.well_known_regex = KNOWN_REGEX_HTTP_HEADER_VALUE];
 }
 ```

 #### KnownRegex

 `well_known_regex` contains some well-known patterns.

 | Name                          | Number | Description                               |
 |-------------------------------|--------|-------------------------------------------|
 | KNOWN_REGEX_UNSPECIFIED       | 0      |                                           |
 | KNOWN_REGEX_HTTP_HEADER_NAME  | 1      | HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2)  |
 | KNOWN_REGEX_HTTP_HEADER_VALUE | 2      | HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4) |
      .buf.validate.KnownRegex well_known_regex = 24 [json_name = "wellKnownRegex", (.buf.validate.priv.field) = { ... }
      Returns:
      Whether the wellKnownRegex field is set.

    • getWellKnownRegexValue

      int getWellKnownRegexValue()
       `well_known_regex` specifies a common well-known pattern
 defined as a regex. If the field value doesn't match the well-known
 regex, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid HTTP header value
   string value = 1 [(buf.validate.field).string.well_known_regex = KNOWN_REGEX_HTTP_HEADER_VALUE];
 }
 ```

 #### KnownRegex

 `well_known_regex` contains some well-known patterns.

 | Name                          | Number | Description                               |
 |-------------------------------|--------|-------------------------------------------|
 | KNOWN_REGEX_UNSPECIFIED       | 0      |                                           |
 | KNOWN_REGEX_HTTP_HEADER_NAME  | 1      | HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2)  |
 | KNOWN_REGEX_HTTP_HEADER_VALUE | 2      | HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4) |
      .buf.validate.KnownRegex well_known_regex = 24 [json_name = "wellKnownRegex", (.buf.validate.priv.field) = { ... }
      Returns:
      The enum numeric value on the wire for wellKnownRegex.

    • getWellKnownRegex

      KnownRegex getWellKnownRegex()
       `well_known_regex` specifies a common well-known pattern
 defined as a regex. If the field value doesn't match the well-known
 regex, an error message will be generated.

 ```proto
 message MyString {
   // value must be a valid HTTP header value
   string value = 1 [(buf.validate.field).string.well_known_regex = KNOWN_REGEX_HTTP_HEADER_VALUE];
 }
 ```

 #### KnownRegex

 `well_known_regex` contains some well-known patterns.

 | Name                          | Number | Description                               |
 |-------------------------------|--------|-------------------------------------------|
 | KNOWN_REGEX_UNSPECIFIED       | 0      |                                           |
 | KNOWN_REGEX_HTTP_HEADER_NAME  | 1      | HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2)  |
 | KNOWN_REGEX_HTTP_HEADER_VALUE | 2      | HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4) |
      .buf.validate.KnownRegex well_known_regex = 24 [json_name = "wellKnownRegex", (.buf.validate.priv.field) = { ... }
      Returns:
      The wellKnownRegex.

    • hasStrict

      boolean hasStrict()
       This applies to regexes `HTTP_HEADER_NAME` and `HTTP_HEADER_VALUE` to
 enable strict header validation. By default, this is true, and HTTP header
 validations are [RFC-compliant](https://tools.ietf.org/html/rfc7230#section-3). Setting to false will enable looser
 validations that only disallow `\r\n\0` characters, which can be used to
 bypass header matching rules.

 ```proto
 message MyString {
   // The field `value` must have be a valid HTTP headers, but not enforced with strict rules.
   string value = 1 [(buf.validate.field).string.strict = false];
 }
 ```
      optional bool strict = 25 [json_name = "strict"];
      Returns:
      Whether the strict field is set.

    • getStrict

      boolean getStrict()
       This applies to regexes `HTTP_HEADER_NAME` and `HTTP_HEADER_VALUE` to
 enable strict header validation. By default, this is true, and HTTP header
 validations are [RFC-compliant](https://tools.ietf.org/html/rfc7230#section-3). Setting to false will enable looser
 validations that only disallow `\r\n\0` characters, which can be used to
 bypass header matching rules.

 ```proto
 message MyString {
   // The field `value` must have be a valid HTTP headers, but not enforced with strict rules.
   string value = 1 [(buf.validate.field).string.strict = false];
 }
 ```
      optional bool strict = 25 [json_name = "strict"];
      Returns:
      The strict.

    • getWellKnownCase

      StringRules.WellKnownCase getWellKnownCase()