@nebius/js-sdk 0.1.0

package/dist/esm/api/buf/validate/index.d.ts

@@ -0,0 +1,2681 @@
+import { Long, unknownFieldsSymbol } from "../../../runtime/protos/index";
+import type { Dayjs, Duration, MessageFns, EnumInstance, EnumClass } from "../../../runtime/protos/index";
+import { customJson } from "../../../runtime/util/logging";
+import { FieldDescriptorProto_Type } from "../../google/protobuf";
+/**
+ *  Specifies how FieldConstraints.ignore behaves. See the documentation for
+ *  FieldConstraints.required for definitions of "populated" and "nullable".
+ *
+ */
+export type Ignore = EnumInstance<"UNRECOGNIZED" | "IGNORE_UNSPECIFIED" | "IGNORE_IF_UNPOPULATED" | "IGNORE_IF_DEFAULT_VALUE" | "IGNORE_ALWAYS" | "IGNORE_EMPTY" | "IGNORE_DEFAULT">;
+interface IgnoreValueMembers {
+    /**
+     *  Validation is only skipped if it's an unpopulated nullable fields.
+     *
+     *  ```proto
+     *  syntax="proto3";
+     *
+     *  message Request {
+     *    // The uri rule applies to any value, including the empty string.
+     *    string foo = 1 [
+     *      (buf.validate.field).string.uri = true
+     *    ];
+     *
+     *    // The uri rule only applies if the field is set, including if it's
+     *    // set to the empty string.
+     *    optional string bar = 2 [
+     *      (buf.validate.field).string.uri = true
+     *    ];
+     *
+     *    // The min_items rule always applies, even if the list is empty.
+     *    repeated string baz = 3 [
+     *      (buf.validate.field).repeated.min_items = 3
+     *    ];
+     *
+     *    // The custom CEL rule applies only if the field is set, including if
+     *    // it's the "zero" value of that message.
+     *    SomeMessage quux = 4 [
+     *      (buf.validate.field).cel = {/* ... * /}
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    readonly IGNORE_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "IGNORE_UNSPECIFIED" | "IGNORE_IF_UNPOPULATED" | "IGNORE_IF_DEFAULT_VALUE" | "IGNORE_ALWAYS" | "IGNORE_EMPTY" | "IGNORE_DEFAULT">;
+    /**
+     *  Validation is skipped if the field is unpopulated. This rule is redundant
+     *  if the field is already nullable. This value is equivalent behavior to the
+     *  deprecated ignore_empty rule.
+     *
+     *  ```proto
+     *  syntax="proto3
+     *
+     *  message Request {
+     *    // The uri rule applies only if the value is not the empty string.
+     *    string foo = 1 [
+     *      (buf.validate.field).string.uri = true,
+     *      (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED
+     *    ];
+     *
+     *    // IGNORE_IF_UNPOPULATED is equivalent to IGNORE_UNSPECIFIED in this
+     *    // case: the uri rule only applies if the field is set, including if
+     *    // it's set to the empty string.
+     *    optional string bar = 2 [
+     *      (buf.validate.field).string.uri = true,
+     *      (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED
+     *    ];
+     *
+     *    // The min_items rule only applies if the list has at least one item.
+     *    repeated string baz = 3 [
+     *      (buf.validate.field).repeated.min_items = 3,
+     *      (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED
+     *    ];
+     *
+     *    // IGNORE_IF_UNPOPULATED is equivalent to IGNORE_UNSPECIFIED in this
+     *    // case: the custom CEL rule applies only if the field is set, including
+     *    // if it's the "zero" value of that message.
+     *    SomeMessage quux = 4 [
+     *      (buf.validate.field).cel = {/* ... * /},
+     *      (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    readonly IGNORE_IF_UNPOPULATED: EnumInstance<"UNRECOGNIZED" | "IGNORE_UNSPECIFIED" | "IGNORE_IF_UNPOPULATED" | "IGNORE_IF_DEFAULT_VALUE" | "IGNORE_ALWAYS" | "IGNORE_EMPTY" | "IGNORE_DEFAULT">;
+    /**
+     *  Validation is skipped if the field is unpopulated or if it is a nullable
+     *  field populated with its default value. This is typically the zero or
+     *  empty value, but proto2 scalars support custom defaults. For messages, the
+     *  default is a non-null message with all its fields unpopulated.
+     *
+     *  ```proto
+     *  syntax="proto3
+     *
+     *  message Request {
+     *    // IGNORE_IF_DEFAULT_VALUE is equivalent to IGNORE_IF_UNPOPULATED in
+     *    // this case; the uri rule applies only if the value is not the empty
+     *    // string.
+     *    string foo = 1 [
+     *      (buf.validate.field).string.uri = true,
+     *      (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE
+     *    ];
+     *
+     *    // The uri rule only applies if the field is set to a value other than
+     *    // the empty string.
+     *    optional string bar = 2 [
+     *      (buf.validate.field).string.uri = true,
+     *      (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE
+     *    ];
+     *
+     *    // IGNORE_IF_DEFAULT_VALUE is equivalent to IGNORE_IF_UNPOPULATED in
+     *    // this case; the min_items rule only applies if the list has at least
+     *    // one item.
+     *    repeated string baz = 3 [
+     *      (buf.validate.field).repeated.min_items = 3,
+     *      (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE
+     *    ];
+     *
+     *    // The custom CEL rule only applies if the field is set to a value other
+     *    // than an empty message (i.e., fields are unpopulated).
+     *    SomeMessage quux = 4 [
+     *      (buf.validate.field).cel = {/* ... * /},
+     *      (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE
+     *    ];
+     *  }
+     *  ```
+     *
+     *  This rule is affected by proto2 custom default values:
+     *
+     *  ```proto
+     *  syntax="proto2";
+     *
+     *  message Request {
+     *    // The gt rule only applies if the field is set and it's value is not
+     *    the default (i.e., not -42). The rule even applies if the field is set
+     *    to zero since the default value differs.
+     *    optional int32 value = 1 [
+     *      default = -42,
+     *      (buf.validate.field).int32.gt = 0,
+     *      (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE
+     *    ];
+     *  }
+     *
+     */
+    readonly IGNORE_IF_DEFAULT_VALUE: EnumInstance<"UNRECOGNIZED" | "IGNORE_UNSPECIFIED" | "IGNORE_IF_UNPOPULATED" | "IGNORE_IF_DEFAULT_VALUE" | "IGNORE_ALWAYS" | "IGNORE_EMPTY" | "IGNORE_DEFAULT">;
+    /**
+     *  The validation rules of this field will be skipped and not evaluated. This
+     *  is useful for situations that necessitate turning off the rules of a field
+     *  containing a message that may not make sense in the current context, or to
+     *  temporarily disable constraints during development.
+     *
+     *  ```proto
+     *  message MyMessage {
+     *    // The field's rules will always be ignored, including any validation's
+     *    // on value's fields.
+     *    MyOtherMessage value = 1 [
+     *      (buf.validate.field).ignore = IGNORE_ALWAYS];
+     *  }
+     *  ```
+     *
+     */
+    readonly IGNORE_ALWAYS: EnumInstance<"UNRECOGNIZED" | "IGNORE_UNSPECIFIED" | "IGNORE_IF_UNPOPULATED" | "IGNORE_IF_DEFAULT_VALUE" | "IGNORE_ALWAYS" | "IGNORE_EMPTY" | "IGNORE_DEFAULT">;
+    /**
+     *  Deprecated: Use IGNORE_IF_UNPOPULATED instead. TODO: Remove this value pre-v1.
+     *
+     * @deprecated Deprecated.
+     */
+    readonly IGNORE_EMPTY: EnumInstance<"UNRECOGNIZED" | "IGNORE_UNSPECIFIED" | "IGNORE_IF_UNPOPULATED" | "IGNORE_IF_DEFAULT_VALUE" | "IGNORE_ALWAYS" | "IGNORE_EMPTY" | "IGNORE_DEFAULT">;
+    /**
+     *  Deprecated: Use IGNORE_IF_DEFAULT_VALUE. TODO: Remove this value pre-v1.
+     *
+     * @deprecated Deprecated.
+     */
+    readonly IGNORE_DEFAULT: EnumInstance<"UNRECOGNIZED" | "IGNORE_UNSPECIFIED" | "IGNORE_IF_UNPOPULATED" | "IGNORE_IF_DEFAULT_VALUE" | "IGNORE_ALWAYS" | "IGNORE_EMPTY" | "IGNORE_DEFAULT">;
+}
+export type IgnoreClass = EnumClass<"UNRECOGNIZED" | "IGNORE_UNSPECIFIED" | "IGNORE_IF_UNPOPULATED" | "IGNORE_IF_DEFAULT_VALUE" | "IGNORE_ALWAYS" | "IGNORE_EMPTY" | "IGNORE_DEFAULT"> & IgnoreValueMembers;
+export declare const Ignore: IgnoreClass;
+/**
+ *  WellKnownRegex contain some well-known patterns.
+ *
+ */
+export type KnownRegex = EnumInstance<"UNRECOGNIZED" | "KNOWN_REGEX_UNSPECIFIED" | "KNOWN_REGEX_HTTP_HEADER_NAME" | "KNOWN_REGEX_HTTP_HEADER_VALUE">;
+interface KnownRegexValueMembers {
+    readonly KNOWN_REGEX_UNSPECIFIED: EnumInstance<"UNRECOGNIZED" | "KNOWN_REGEX_UNSPECIFIED" | "KNOWN_REGEX_HTTP_HEADER_NAME" | "KNOWN_REGEX_HTTP_HEADER_VALUE">;
+    /**
+     *  HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2).
+     *
+     */
+    readonly KNOWN_REGEX_HTTP_HEADER_NAME: EnumInstance<"UNRECOGNIZED" | "KNOWN_REGEX_UNSPECIFIED" | "KNOWN_REGEX_HTTP_HEADER_NAME" | "KNOWN_REGEX_HTTP_HEADER_VALUE">;
+    /**
+     *  HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4).
+     *
+     */
+    readonly KNOWN_REGEX_HTTP_HEADER_VALUE: EnumInstance<"UNRECOGNIZED" | "KNOWN_REGEX_UNSPECIFIED" | "KNOWN_REGEX_HTTP_HEADER_NAME" | "KNOWN_REGEX_HTTP_HEADER_VALUE">;
+}
+export type KnownRegexClass = EnumClass<"UNRECOGNIZED" | "KNOWN_REGEX_UNSPECIFIED" | "KNOWN_REGEX_HTTP_HEADER_NAME" | "KNOWN_REGEX_HTTP_HEADER_VALUE"> & KnownRegexValueMembers;
+export declare const KnownRegex: KnownRegexClass;
+/**
+ *  `Constraint` represents a validation rule written in the Common Expression
+ *  Language (CEL) syntax. Each Constraint includes a unique identifier, an
+ *  optional error message, and the CEL expression to evaluate. For more
+ *  information on CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).
+ *
+ *  ```proto
+ *  message Foo {
+ *    option (buf.validate.message).cel = {
+ *      id: "foo.bar"
+ *      message: "bar must be greater than 0"
+ *      expression: "this.bar > 0"
+ *    };
+ *    int32 bar = 1;
+ *  }
+ *  ```
+ *
+ */
+export interface Constraint {
+    $type: "buf.validate.Constraint";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `id` is a string that serves as a machine-readable name for this Constraint.
+     *  It should be unique within its scope, which could be either a message or a field.
+     *
+     */
+    id?: string | undefined;
+    /**
+     *  `message` is an optional field that provides a human-readable error message
+     *  for this Constraint when the CEL expression evaluates to false. If a
+     *  non-empty message is provided, any strings resulting from the CEL
+     *  expression evaluation are ignored.
+     *
+     */
+    message?: string | undefined;
+    /**
+     *  `expression` is the actual CEL expression that will be evaluated for
+     *  validation. This string must resolve to either a boolean or a string
+     *  value. If the expression evaluates to false or a non-empty string, the
+     *  validation is considered failed, and the message is rejected.
+     *
+     */
+    expression?: string | undefined;
+}
+export declare const Constraint: MessageFns<Constraint, "buf.validate.Constraint">;
+/**
+ *  MessageConstraints represents validation rules that are applied to the entire message.
+ *  It includes disabling options and a list of Constraint messages representing Common Expression Language (CEL) validation rules.
+ *
+ */
+export interface MessageConstraints {
+    $type: "buf.validate.MessageConstraints";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `disabled` is a boolean flag that, when set to true, nullifies any validation rules for this message.
+     *  This includes any fields within the message that would otherwise support validation.
+     *
+     *  ```proto
+     *  message MyMessage {
+     *    // validation will be bypassed for this message
+     *    option (buf.validate.message).disabled = true;
+     *  }
+     *  ```
+     *
+     */
+    disabled?: boolean | undefined;
+    /**
+     *  `cel` is a repeated field of type Constraint. Each Constraint specifies a validation rule to be applied to this message.
+     *  These constraints are written in Common Expression Language (CEL) syntax. For more information on
+     *  CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).
+     *
+     *
+     *  ```proto
+     *  message MyMessage {
+     *    // The field `foo` must be greater than 42.
+     *    option (buf.validate.message).cel = {
+     *      id: "my_message.value",
+     *      message: "value must be greater than 42",
+     *      expression: "this.foo > 42",
+     *    };
+     *    optional int32 foo = 1;
+     *  }
+     *  ```
+     *
+     */
+    cel: Constraint[];
+}
+export declare const MessageConstraints: MessageFns<MessageConstraints, "buf.validate.MessageConstraints">;
+/**
+ *  The `OneofConstraints` message type enables you to manage constraints for
+ *  oneof fields in your protobuf messages.
+ *
+ */
+export interface OneofConstraints {
+    $type: "buf.validate.OneofConstraints";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  If `required` is true, exactly one field of the oneof must be present. A
+     *  validation error is returned if no fields in the oneof are present. The
+     *  field itself may still be a default value; further constraints
+     *  should be placed on the fields themselves to ensure they are valid values,
+     *  such as `min_len` or `gt`.
+     *
+     *  ```proto
+     *  message MyMessage {
+     *    oneof value {
+     *      // Either `a` or `b` must be set. If `a` is set, it must also be
+     *      // non-empty; whereas if `b` is set, it can still be an empty string.
+     *      option (buf.validate.oneof).required = true;
+     *      string a = 1 [(buf.validate.field).string.min_len = 1];
+     *      string b = 2;
+     *    }
+     *  }
+     *  ```
+     *
+     */
+    required?: boolean | undefined;
+}
+export declare const OneofConstraints: MessageFns<OneofConstraints, "buf.validate.OneofConstraints">;
+/**
+ *  FieldConstraints encapsulates the rules for each type of field. Depending on
+ *  the field, the correct set should be used to ensure proper validations.
+ *
+ */
+export interface FieldConstraints {
+    $type: "buf.validate.FieldConstraints";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `cel` is a repeated field used to represent a textual expression
+     *  in the Common Expression Language (CEL) syntax. For more information on
+     *  CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).
+     *
+     *  ```proto
+     *  message MyMessage {
+     *    // The field `value` must be greater than 42.
+     *    optional int32 value = 1 [(buf.validate.field).cel = {
+     *      id: "my_message.value",
+     *      message: "value must be greater than 42",
+     *      expression: "this > 42",
+     *    }];
+     *  }
+     *  ```
+     *
+     */
+    cel: Constraint[];
+    /**
+     *  If `required` is true, the field must be populated. A populated field can be
+     *  described as "serialized in the wire format," which includes:
+     *
+     *  - the following "nullable" fields must be explicitly set to be considered populated:
+     *    - singular message fields (whose fields may be unpopulated/default values)
+     *    - member fields of a oneof (may be their default value)
+     *    - proto3 optional fields (may be their default value)
+     *    - proto2 scalar fields (both optional and required)
+     *  - proto3 scalar fields must be non-zero to be considered populated
+     *  - repeated and map fields must be non-empty to be considered populated
+     *
+     *  ```proto
+     *  message MyMessage {
+     *    // The field `value` must be set to a non-null value.
+     *    optional MyOtherMessage value = 1 [(buf.validate.field).required = true];
+     *  }
+     *  ```
+     *
+     */
+    required?: boolean | undefined;
+    /**
+     *  Skip validation on the field if its value matches the specified criteria.
+     *  See Ignore enum for details.
+     *
+     *  ```proto
+     *  message UpdateRequest {
+     *    // The uri rule only applies if the field is populated and not an empty
+     *    // string.
+     *    optional string url = 1 [
+     *      (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE,
+     *      (buf.validate.field).string.uri = true,
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    ignore?: Ignore | undefined;
+    /**
+     *  DEPRECATED: use ignore=IGNORE_ALWAYS instead. TODO: remove this field pre-v1.
+     *
+     * @deprecated Deprecated.
+     */
+    skipped?: boolean | undefined;
+    /**
+     *  DEPRECATED: use ignore=IGNORE_IF_UNPOPULATED instead. TODO: remove this field pre-v1.
+     *
+     * @deprecated Deprecated.
+     */
+    ignoreEmpty?: boolean | undefined;
+    type?: {
+        $case: "float";
+        float: FloatRules;
+    } | {
+        $case: "double";
+        double: DoubleRules;
+    } | {
+        $case: "int32";
+        int32: Int32Rules;
+    } | {
+        $case: "int64";
+        int64: Int64Rules;
+    } | {
+        $case: "uint32";
+        uint32: UInt32Rules;
+    } | {
+        $case: "uint64";
+        uint64: UInt64Rules;
+    } | {
+        $case: "sint32";
+        sint32: SInt32Rules;
+    } | {
+        $case: "sint64";
+        sint64: SInt64Rules;
+    } | {
+        $case: "fixed32";
+        fixed32: Fixed32Rules;
+    } | {
+        $case: "fixed64";
+        fixed64: Fixed64Rules;
+    } | {
+        $case: "sfixed32";
+        sfixed32: SFixed32Rules;
+    } | {
+        $case: "sfixed64";
+        sfixed64: SFixed64Rules;
+    } | {
+        $case: "bool";
+        bool: BoolRules;
+    } | {
+        $case: "string";
+        string: StringRules;
+    } | {
+        $case: "bytes";
+        bytes: BytesRules;
+    } | {
+        $case: "enum";
+        enum: EnumRules;
+    } | {
+        $case: "repeated";
+        repeated: RepeatedRules;
+    } | {
+        $case: "map";
+        map: MapRules;
+    } | {
+        $case: "any";
+        any: AnyRules;
+    } | {
+        $case: "duration";
+        duration: DurationRules;
+    } | {
+        $case: "timestamp";
+        timestamp: TimestampRules;
+    } | undefined;
+}
+export declare const FieldConstraints: MessageFns<FieldConstraints, "buf.validate.FieldConstraints">;
+/**
+ *  PredefinedConstraints are custom constraints that can be re-used with
+ *  multiple fields.
+ *
+ */
+export interface PredefinedConstraints {
+    $type: "buf.validate.PredefinedConstraints";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `cel` is a repeated field used to represent a textual expression
+     *  in the Common Expression Language (CEL) syntax. For more information on
+     *  CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).
+     *
+     *  ```proto
+     *  message MyMessage {
+     *    // The field `value` must be greater than 42.
+     *    optional int32 value = 1 [(buf.validate.predefined).cel = {
+     *      id: "my_message.value",
+     *      message: "value must be greater than 42",
+     *      expression: "this > 42",
+     *    }];
+     *  }
+     *  ```
+     *
+     */
+    cel: Constraint[];
+}
+export declare const PredefinedConstraints: MessageFns<PredefinedConstraints, "buf.validate.PredefinedConstraints">;
+/**
+ *  FloatRules describes the constraints applied to `float` values. These
+ *  rules may also be applied to the `google.protobuf.FloatValue` Well-Known-Type.
+ *
+ */
+export interface FloatRules {
+    $type: "buf.validate.FloatRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MyFloat {
+     *    // value must equal 42.0
+     *    float value = 1 [(buf.validate.field).float.const = 42.0];
+     *  }
+     *  ```
+     *
+     */
+    const?: number | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message
+     *  is generated.
+     *
+     *  ```proto
+     *  message MyFloat {
+     *    // value must be in list [1.0, 2.0, 3.0]
+     *    repeated float value = 1 (buf.validate.field).float = { in: [1.0, 2.0, 3.0] };
+     *  }
+     *  ```
+     *
+     */
+    in: number[];
+    /**
+     *  `in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MyFloat {
+     *    // value must not be in list [1.0, 2.0, 3.0]
+     *    repeated float value = 1 (buf.validate.field).float = { not_in: [1.0, 2.0, 3.0] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: number[];
+    /**
+     *  `finite` requires the field value to be finite. If the field value is
+     *  infinite or NaN, an error message is generated.
+     *
+     */
+    finite?: boolean | undefined;
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyFloat {
+     *    float value = 1 [
+     *      (buf.validate.field).float.example = 1.0,
+     *      (buf.validate.field).float.example = "Infinity"
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: number[];
+    lessThan?: {
+        $case: "lt";
+        lt: number;
+    } | {
+        $case: "lte";
+        lte: number;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: number;
+    } | {
+        $case: "gte";
+        gte: number;
+    } | undefined;
+}
+export declare const FloatRules: MessageFns<FloatRules, "buf.validate.FloatRules">;
+/**
+ *  DoubleRules describes the constraints applied to `double` values. These
+ *  rules may also be applied to the `google.protobuf.DoubleValue` Well-Known-Type.
+ *
+ */
+export interface DoubleRules {
+    $type: "buf.validate.DoubleRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MyDouble {
+     *    // value must equal 42.0
+     *    double value = 1 [(buf.validate.field).double.const = 42.0];
+     *  }
+     *  ```
+     *
+     */
+    const?: number | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MyDouble {
+     *    // value must be in list [1.0, 2.0, 3.0]
+     *    repeated double value = 1 (buf.validate.field).double = { in: [1.0, 2.0, 3.0] };
+     *  }
+     *  ```
+     *
+     */
+    in: number[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MyDouble {
+     *    // value must not be in list [1.0, 2.0, 3.0]
+     *    repeated double value = 1 (buf.validate.field).double = { not_in: [1.0, 2.0, 3.0] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: number[];
+    /**
+     *  `finite` requires the field value to be finite. If the field value is
+     *  infinite or NaN, an error message is generated.
+     *
+     */
+    finite?: boolean | undefined;
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyDouble {
+     *    double value = 1 [
+     *      (buf.validate.field).double.example = 1.0,
+     *      (buf.validate.field).double.example = "Infinity"
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: number[];
+    lessThan?: {
+        $case: "lt";
+        lt: number;
+    } | {
+        $case: "lte";
+        lte: number;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: number;
+    } | {
+        $case: "gte";
+        gte: number;
+    } | undefined;
+}
+export declare const DoubleRules: MessageFns<DoubleRules, "buf.validate.DoubleRules">;
+/**
+ *  Int32Rules describes the constraints applied to `int32` values. These
+ *  rules may also be applied to the `google.protobuf.Int32Value` Well-Known-Type.
+ *
+ */
+export interface Int32Rules {
+    $type: "buf.validate.Int32Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MyInt32 {
+     *    // value must equal 42
+     *    int32 value = 1 [(buf.validate.field).int32.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: number | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MyInt32 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated int32 value = 1 (buf.validate.field).int32 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: number[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error message
+     *  is generated.
+     *
+     *  ```proto
+     *  message MyInt32 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated int32 value = 1 (buf.validate.field).int32 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: number[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyInt32 {
+     *    int32 value = 1 [
+     *      (buf.validate.field).int32.example = 1,
+     *      (buf.validate.field).int32.example = -10
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: number[];
+    lessThan?: {
+        $case: "lt";
+        lt: number;
+    } | {
+        $case: "lte";
+        lte: number;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: number;
+    } | {
+        $case: "gte";
+        gte: number;
+    } | undefined;
+}
+export declare const Int32Rules: MessageFns<Int32Rules, "buf.validate.Int32Rules">;
+/**
+ *  Int64Rules describes the constraints applied to `int64` values. These
+ *  rules may also be applied to the `google.protobuf.Int64Value` Well-Known-Type.
+ *
+ */
+export interface Int64Rules {
+    $type: "buf.validate.Int64Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MyInt64 {
+     *    // value must equal 42
+     *    int64 value = 1 [(buf.validate.field).int64.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: Long | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MyInt64 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated int64 value = 1 (buf.validate.field).int64 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: Long[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MyInt64 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated int64 value = 1 (buf.validate.field).int64 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: Long[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyInt64 {
+     *    int64 value = 1 [
+     *      (buf.validate.field).int64.example = 1,
+     *      (buf.validate.field).int64.example = -10
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: Long[];
+    lessThan?: {
+        $case: "lt";
+        lt: Long;
+    } | {
+        $case: "lte";
+        lte: Long;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: Long;
+    } | {
+        $case: "gte";
+        gte: Long;
+    } | undefined;
+}
+export declare const Int64Rules: MessageFns<Int64Rules, "buf.validate.Int64Rules">;
+/**
+ *  UInt32Rules describes the constraints applied to `uint32` values. These
+ *  rules may also be applied to the `google.protobuf.UInt32Value` Well-Known-Type.
+ *
+ */
+export interface UInt32Rules {
+    $type: "buf.validate.UInt32Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MyUInt32 {
+     *    // value must equal 42
+     *    uint32 value = 1 [(buf.validate.field).uint32.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: number | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MyUInt32 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated uint32 value = 1 (buf.validate.field).uint32 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: number[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MyUInt32 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated uint32 value = 1 (buf.validate.field).uint32 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: number[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyUInt32 {
+     *    uint32 value = 1 [
+     *      (buf.validate.field).uint32.example = 1,
+     *      (buf.validate.field).uint32.example = 10
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: number[];
+    lessThan?: {
+        $case: "lt";
+        lt: number;
+    } | {
+        $case: "lte";
+        lte: number;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: number;
+    } | {
+        $case: "gte";
+        gte: number;
+    } | undefined;
+}
+export declare const UInt32Rules: MessageFns<UInt32Rules, "buf.validate.UInt32Rules">;
+/**
+ *  UInt64Rules describes the constraints applied to `uint64` values. These
+ *  rules may also be applied to the `google.protobuf.UInt64Value` Well-Known-Type.
+ *
+ */
+export interface UInt64Rules {
+    $type: "buf.validate.UInt64Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MyUInt64 {
+     *    // value must equal 42
+     *    uint64 value = 1 [(buf.validate.field).uint64.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: Long | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MyUInt64 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated uint64 value = 1 (buf.validate.field).uint64 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: Long[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MyUInt64 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated uint64 value = 1 (buf.validate.field).uint64 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: Long[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyUInt64 {
+     *    uint64 value = 1 [
+     *      (buf.validate.field).uint64.example = 1,
+     *      (buf.validate.field).uint64.example = -10
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: Long[];
+    lessThan?: {
+        $case: "lt";
+        lt: Long;
+    } | {
+        $case: "lte";
+        lte: Long;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: Long;
+    } | {
+        $case: "gte";
+        gte: Long;
+    } | undefined;
+}
+export declare const UInt64Rules: MessageFns<UInt64Rules, "buf.validate.UInt64Rules">;
+/**
+ *  SInt32Rules describes the constraints applied to `sint32` values.
+ *
+ */
+export interface SInt32Rules {
+    $type: "buf.validate.SInt32Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MySInt32 {
+     *    // value must equal 42
+     *    sint32 value = 1 [(buf.validate.field).sint32.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: number | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MySInt32 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated sint32 value = 1 (buf.validate.field).sint32 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: number[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MySInt32 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated sint32 value = 1 (buf.validate.field).sint32 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: number[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MySInt32 {
+     *    sint32 value = 1 [
+     *      (buf.validate.field).sint32.example = 1,
+     *      (buf.validate.field).sint32.example = -10
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: number[];
+    lessThan?: {
+        $case: "lt";
+        lt: number;
+    } | {
+        $case: "lte";
+        lte: number;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: number;
+    } | {
+        $case: "gte";
+        gte: number;
+    } | undefined;
+}
+export declare const SInt32Rules: MessageFns<SInt32Rules, "buf.validate.SInt32Rules">;
+/**
+ *  SInt64Rules describes the constraints applied to `sint64` values.
+ *
+ */
+export interface SInt64Rules {
+    $type: "buf.validate.SInt64Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MySInt64 {
+     *    // value must equal 42
+     *    sint64 value = 1 [(buf.validate.field).sint64.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: Long | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message
+     *  is generated.
+     *
+     *  ```proto
+     *  message MySInt64 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated sint64 value = 1 (buf.validate.field).sint64 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: Long[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MySInt64 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated sint64 value = 1 (buf.validate.field).sint64 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: Long[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MySInt64 {
+     *    sint64 value = 1 [
+     *      (buf.validate.field).sint64.example = 1,
+     *      (buf.validate.field).sint64.example = -10
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: Long[];
+    lessThan?: {
+        $case: "lt";
+        lt: Long;
+    } | {
+        $case: "lte";
+        lte: Long;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: Long;
+    } | {
+        $case: "gte";
+        gte: Long;
+    } | undefined;
+}
+export declare const SInt64Rules: MessageFns<SInt64Rules, "buf.validate.SInt64Rules">;
+/**
+ *  Fixed32Rules describes the constraints applied to `fixed32` values.
+ *
+ */
+export interface Fixed32Rules {
+    $type: "buf.validate.Fixed32Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MyFixed32 {
+     *    // value must equal 42
+     *    fixed32 value = 1 [(buf.validate.field).fixed32.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: number | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message
+     *  is generated.
+     *
+     *  ```proto
+     *  message MyFixed32 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated fixed32 value = 1 (buf.validate.field).fixed32 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: number[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MyFixed32 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated fixed32 value = 1 (buf.validate.field).fixed32 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: number[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyFixed32 {
+     *    fixed32 value = 1 [
+     *      (buf.validate.field).fixed32.example = 1,
+     *      (buf.validate.field).fixed32.example = 2
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: number[];
+    lessThan?: {
+        $case: "lt";
+        lt: number;
+    } | {
+        $case: "lte";
+        lte: number;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: number;
+    } | {
+        $case: "gte";
+        gte: number;
+    } | undefined;
+}
+export declare const Fixed32Rules: MessageFns<Fixed32Rules, "buf.validate.Fixed32Rules">;
+/**
+ *  Fixed64Rules describes the constraints applied to `fixed64` values.
+ *
+ */
+export interface Fixed64Rules {
+    $type: "buf.validate.Fixed64Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MyFixed64 {
+     *    // value must equal 42
+     *    fixed64 value = 1 [(buf.validate.field).fixed64.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: Long | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MyFixed64 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated fixed64 value = 1 (buf.validate.field).fixed64 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: Long[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MyFixed64 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated fixed64 value = 1 (buf.validate.field).fixed64 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: Long[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyFixed64 {
+     *    fixed64 value = 1 [
+     *      (buf.validate.field).fixed64.example = 1,
+     *      (buf.validate.field).fixed64.example = 2
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: Long[];
+    lessThan?: {
+        $case: "lt";
+        lt: Long;
+    } | {
+        $case: "lte";
+        lte: Long;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: Long;
+    } | {
+        $case: "gte";
+        gte: Long;
+    } | undefined;
+}
+export declare const Fixed64Rules: MessageFns<Fixed64Rules, "buf.validate.Fixed64Rules">;
+/**
+ *  SFixed32Rules describes the constraints applied to `fixed32` values.
+ *
+ */
+export interface SFixed32Rules {
+    $type: "buf.validate.SFixed32Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MySFixed32 {
+     *    // value must equal 42
+     *    sfixed32 value = 1 [(buf.validate.field).sfixed32.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: number | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MySFixed32 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated sfixed32 value = 1 (buf.validate.field).sfixed32 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: number[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MySFixed32 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated sfixed32 value = 1 (buf.validate.field).sfixed32 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: number[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MySFixed32 {
+     *    sfixed32 value = 1 [
+     *      (buf.validate.field).sfixed32.example = 1,
+     *      (buf.validate.field).sfixed32.example = 2
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: number[];
+    lessThan?: {
+        $case: "lt";
+        lt: number;
+    } | {
+        $case: "lte";
+        lte: number;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: number;
+    } | {
+        $case: "gte";
+        gte: number;
+    } | undefined;
+}
+export declare const SFixed32Rules: MessageFns<SFixed32Rules, "buf.validate.SFixed32Rules">;
+/**
+ *  SFixed64Rules describes the constraints applied to `fixed64` values.
+ *
+ */
+export interface SFixed64Rules {
+    $type: "buf.validate.SFixed64Rules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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 MySFixed64 {
+     *    // value must equal 42
+     *    sfixed64 value = 1 [(buf.validate.field).sfixed64.const = 42];
+     *  }
+     *  ```
+     *
+     */
+    const?: Long | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified values.
+     *  If the field value isn't one of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MySFixed64 {
+     *    // value must be in list [1, 2, 3]
+     *    repeated sfixed64 value = 1 (buf.validate.field).sfixed64 = { in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    in: Long[];
+    /**
+     *  `not_in` requires the field value to not be equal to any of the specified
+     *  values. If the field value is one of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MySFixed64 {
+     *    // value must not be in list [1, 2, 3]
+     *    repeated sfixed64 value = 1 (buf.validate.field).sfixed64 = { not_in: [1, 2, 3] };
+     *  }
+     *  ```
+     *
+     */
+    notIn: Long[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MySFixed64 {
+     *    sfixed64 value = 1 [
+     *      (buf.validate.field).sfixed64.example = 1,
+     *      (buf.validate.field).sfixed64.example = 2
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: Long[];
+    lessThan?: {
+        $case: "lt";
+        lt: Long;
+    } | {
+        $case: "lte";
+        lte: Long;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: Long;
+    } | {
+        $case: "gte";
+        gte: Long;
+    } | undefined;
+}
+export declare const SFixed64Rules: MessageFns<SFixed64Rules, "buf.validate.SFixed64Rules">;
+/**
+ *  BoolRules describes the constraints applied to `bool` values. These rules
+ *  may also be applied to the `google.protobuf.BoolValue` Well-Known-Type.
+ *
+ */
+export interface BoolRules {
+    $type: "buf.validate.BoolRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `const` requires the field value to exactly match the specified boolean value.
+     *  If the field value doesn't match, an error message is generated.
+     *
+     *  ```proto
+     *  message MyBool {
+     *    // value must equal true
+     *    bool value = 1 [(buf.validate.field).bool.const = true];
+     *  }
+     *  ```
+     *
+     */
+    const?: boolean | undefined;
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyBool {
+     *    bool value = 1 [
+     *      (buf.validate.field).bool.example = 1,
+     *      (buf.validate.field).bool.example = 2
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: boolean[];
+}
+export declare const BoolRules: MessageFns<BoolRules, "buf.validate.BoolRules">;
+/**
+ *  StringRules describes the constraints applied to `string` values These
+ *  rules may also be applied to the `google.protobuf.StringValue` Well-Known-Type.
+ *
+ */
+export interface StringRules {
+    $type: "buf.validate.StringRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `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"];
+     *  }
+     *  ```
+     *
+     */
+    const?: string | undefined;
+    /**
+     *  `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];
+     *  }
+     *  ```
+     *
+     */
+    len?: Long | undefined;
+    /**
+     *  `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];
+     *  }
+     *  ```
+     *
+     */
+    minLen?: Long | undefined;
+    /**
+     *  `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];
+     *  }
+     *  ```
+     *
+     */
+    maxLen?: Long | undefined;
+    /**
+     *  `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];
+     *  }
+     *  ```
+     *
+     */
+    lenBytes?: Long | undefined;
+    /**
+     *  `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];
+     *  }
+     *
+     *  ```
+     *
+     */
+    minBytes?: Long | undefined;
+    /**
+     *  `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];
+     *  }
+     *  ```
+     *
+     */
+    maxBytes?: Long | undefined;
+    /**
+     *  `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]//$"];
+     *  }
+     *  ```
+     *
+     */
+    pattern?: string | undefined;
+    /**
+     *  `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"];
+     *  }
+     *  ```
+     *
+     */
+    prefix?: string | undefined;
+    /**
+     *  `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"];
+     *  }
+     *  ```
+     *
+     */
+    suffix?: string | undefined;
+    /**
+     *  `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"];
+     *  }
+     *  ```
+     *
+     */
+    contains?: string | undefined;
+    /**
+     *  `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"];
+     *  }
+     *  ```
+     *
+     */
+    notContains?: string | undefined;
+    /**
+     *  `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"];
+     *  }
+     *  ```
+     *
+     */
+    in: string[];
+    /**
+     *  `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"];
+     *  }
+     *  ```
+     *
+     */
+    notIn: string[];
+    /**
+     *  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];
+     *  }
+     *  ```
+     *
+     */
+    strict?: boolean | undefined;
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyString {
+     *    string value = 1 [
+     *      (buf.validate.field).string.example = "hello",
+     *      (buf.validate.field).string.example = "world"
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: string[];
+    /**
+     *  `WellKnown` rules provide advanced constraints against common string
+     *  patterns
+     *
+     */
+    wellKnown?: {
+        $case: "email";
+        email: boolean;
+    } | {
+        $case: "hostname";
+        hostname: boolean;
+    } | {
+        $case: "ip";
+        ip: boolean;
+    } | {
+        $case: "ipv4";
+        ipv4: boolean;
+    } | {
+        $case: "ipv6";
+        ipv6: boolean;
+    } | {
+        $case: "uri";
+        uri: boolean;
+    } | {
+        $case: "uriRef";
+        uriRef: boolean;
+    } | {
+        $case: "address";
+        address: boolean;
+    } | {
+        $case: "uuid";
+        uuid: boolean;
+    } | {
+        $case: "tuuid";
+        tuuid: boolean;
+    } | {
+        $case: "ipWithPrefixlen";
+        ipWithPrefixlen: boolean;
+    } | {
+        $case: "ipv4WithPrefixlen";
+        ipv4WithPrefixlen: boolean;
+    } | {
+        $case: "ipv6WithPrefixlen";
+        ipv6WithPrefixlen: boolean;
+    } | {
+        $case: "ipPrefix";
+        ipPrefix: boolean;
+    } | {
+        $case: "ipv4Prefix";
+        ipv4Prefix: boolean;
+    } | {
+        $case: "ipv6Prefix";
+        ipv6Prefix: boolean;
+    } | {
+        $case: "hostAndPort";
+        hostAndPort: boolean;
+    } | {
+        $case: "wellKnownRegex";
+        wellKnownRegex: KnownRegex;
+    } | undefined;
+}
+export declare const StringRules: MessageFns<StringRules, "buf.validate.StringRules">;
+/**
+ *  BytesRules describe the constraints applied to `bytes` values. These rules
+ *  may also be applied to the `google.protobuf.BytesValue` Well-Known-Type.
+ *
+ */
+export interface BytesRules {
+    $type: "buf.validate.BytesRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `const` requires the field value to exactly match the specified bytes
+     *  value. If the field value doesn't match, an error message is generated.
+     *
+     *  ```proto
+     *  message MyBytes {
+     *    // value must be "\x01\x02\x03\x04"
+     *    bytes value = 1 [(buf.validate.field).bytes.const = "\x01\x02\x03\x04"];
+     *  }
+     *  ```
+     *
+     */
+    const?: Uint8Array | undefined;
+    /**
+     *  `len` requires the field value to have the specified length in bytes.
+     *  If the field value doesn't match, an error message is generated.
+     *
+     *  ```proto
+     *  message MyBytes {
+     *    // value length must be 4 bytes.
+     *    optional bytes value = 1 [(buf.validate.field).bytes.len = 4];
+     *  }
+     *  ```
+     *
+     */
+    len?: Long | undefined;
+    /**
+     *  `min_len` requires the field value to have at least the specified minimum
+     *  length in bytes.
+     *  If the field value doesn't meet the requirement, an error message is generated.
+     *
+     *  ```proto
+     *  message MyBytes {
+     *    // value length must be at least 2 bytes.
+     *    optional bytes value = 1 [(buf.validate.field).bytes.min_len = 2];
+     *  }
+     *  ```
+     *
+     */
+    minLen?: Long | undefined;
+    /**
+     *  `max_len` requires the field value to have at most the specified maximum
+     *  length in bytes.
+     *  If the field value exceeds the requirement, an error message is generated.
+     *
+     *  ```proto
+     *  message MyBytes {
+     *    // value must be at most 6 bytes.
+     *    optional bytes value = 1 [(buf.validate.field).bytes.max_len = 6];
+     *  }
+     *  ```
+     *
+     */
+    maxLen?: Long | undefined;
+    /**
+     *  `pattern` requires the field value to match the specified regular
+     *  expression ([RE2 syntax](https://github.com/google/re2/wiki/Syntax)).
+     *  The value of the field must be valid UTF-8 or validation will fail with a
+     *  runtime error.
+     *  If the field value doesn't match the pattern, an error message is generated.
+     *
+     *  ```proto
+     *  message MyBytes {
+     *    // value must match regex pattern "^[a-zA-Z0-9]+$".
+     *    optional bytes value = 1 [(buf.validate.field).bytes.pattern = "^[a-zA-Z0-9]+$"];
+     *  }
+     *  ```
+     *
+     */
+    pattern?: string | undefined;
+    /**
+     *  `prefix` requires the field value to have the specified bytes at the
+     *  beginning of the string.
+     *  If the field value doesn't meet the requirement, an error message is generated.
+     *
+     *  ```proto
+     *  message MyBytes {
+     *    // value does not have prefix \x01\x02
+     *    optional bytes value = 1 [(buf.validate.field).bytes.prefix = "\x01\x02"];
+     *  }
+     *  ```
+     *
+     */
+    prefix?: Uint8Array | undefined;
+    /**
+     *  `suffix` requires the field value to have the specified bytes at the end
+     *  of the string.
+     *  If the field value doesn't meet the requirement, an error message is generated.
+     *
+     *  ```proto
+     *  message MyBytes {
+     *    // value does not have suffix \x03\x04
+     *    optional bytes value = 1 [(buf.validate.field).bytes.suffix = "\x03\x04"];
+     *  }
+     *  ```
+     *
+     */
+    suffix?: Uint8Array | undefined;
+    /**
+     *  `contains` requires the field value to have the specified bytes anywhere in
+     *  the string.
+     *  If the field value doesn't meet the requirement, an error message is generated.
+     *
+     *  ```protobuf
+     *  message MyBytes {
+     *    // value does not contain \x02\x03
+     *    optional bytes value = 1 [(buf.validate.field).bytes.contains = "\x02\x03"];
+     *  }
+     *  ```
+     *
+     */
+    contains?: Uint8Array | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the specified
+     *  values. If the field value doesn't match any of the specified values, an
+     *  error message is generated.
+     *
+     *  ```protobuf
+     *  message MyBytes {
+     *    // value must in ["\x01\x02", "\x02\x03", "\x03\x04"]
+     *    optional bytes value = 1 [(buf.validate.field).bytes.in = {"\x01\x02", "\x02\x03", "\x03\x04"}];
+     *  }
+     *  ```
+     *
+     */
+    in: Uint8Array[];
+    /**
+     *  `not_in` requires the field value to be not equal to any of the specified
+     *  values.
+     *  If the field value matches any of the specified values, an error message is
+     *  generated.
+     *
+     *  ```proto
+     *  message MyBytes {
+     *    // value must not in ["\x01\x02", "\x02\x03", "\x03\x04"]
+     *    optional bytes value = 1 [(buf.validate.field).bytes.not_in = {"\x01\x02", "\x02\x03", "\x03\x04"}];
+     *  }
+     *  ```
+     *
+     */
+    notIn: Uint8Array[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyBytes {
+     *    bytes value = 1 [
+     *      (buf.validate.field).bytes.example = "\x01\x02",
+     *      (buf.validate.field).bytes.example = "\x02\x03"
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: Uint8Array[];
+    /**
+     *  WellKnown rules provide advanced constraints against common byte
+     *  patterns
+     *
+     */
+    wellKnown?: {
+        $case: "ip";
+        ip: boolean;
+    } | {
+        $case: "ipv4";
+        ipv4: boolean;
+    } | {
+        $case: "ipv6";
+        ipv6: boolean;
+    } | undefined;
+}
+export declare const BytesRules: MessageFns<BytesRules, "buf.validate.BytesRules">;
+/**
+ *  EnumRules describe the constraints applied to `enum` values.
+ *
+ */
+export interface EnumRules {
+    $type: "buf.validate.EnumRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `const` requires the field value to exactly match the specified enum value.
+     *  If the field value doesn't match, an error message is generated.
+     *
+     *  ```proto
+     *  enum MyEnum {
+     *    MY_ENUM_UNSPECIFIED = 0;
+     *    MY_ENUM_VALUE1 = 1;
+     *    MY_ENUM_VALUE2 = 2;
+     *  }
+     *
+     *  message MyMessage {
+     *    // The field `value` must be exactly MY_ENUM_VALUE1.
+     *    MyEnum value = 1 [(buf.validate.field).enum.const = 1];
+     *  }
+     *  ```
+     *
+     */
+    const?: number | undefined;
+    /**
+     *  `defined_only` requires the field value to be one of the defined values for
+     *  this enum, failing on any undefined value.
+     *
+     *  ```proto
+     *  enum MyEnum {
+     *    MY_ENUM_UNSPECIFIED = 0;
+     *    MY_ENUM_VALUE1 = 1;
+     *    MY_ENUM_VALUE2 = 2;
+     *  }
+     *
+     *  message MyMessage {
+     *    // The field `value` must be a defined value of MyEnum.
+     *    MyEnum value = 1 [(buf.validate.field).enum.defined_only = true];
+     *  }
+     *  ```
+     *
+     */
+    definedOnly?: boolean | undefined;
+    /**
+     *  `in` requires the field value to be equal to one of the
+     * specified enum values. If the field value doesn't match any of the
+     * specified values, an error message is generated.
+     *
+     *  ```proto
+     *  enum MyEnum {
+     *    MY_ENUM_UNSPECIFIED = 0;
+     *    MY_ENUM_VALUE1 = 1;
+     *    MY_ENUM_VALUE2 = 2;
+     *  }
+     *
+     *  message MyMessage {
+     *    // The field `value` must be equal to one of the specified values.
+     *    MyEnum value = 1 [(buf.validate.field).enum = { in: [1, 2]}];
+     *  }
+     *  ```
+     *
+     */
+    in: number[];
+    /**
+     *  `not_in` requires the field value to be not equal to any of the
+     * specified enum values. If the field value matches one of the specified
+     *  values, an error message is generated.
+     *
+     *  ```proto
+     *  enum MyEnum {
+     *    MY_ENUM_UNSPECIFIED = 0;
+     *    MY_ENUM_VALUE1 = 1;
+     *    MY_ENUM_VALUE2 = 2;
+     *  }
+     *
+     *  message MyMessage {
+     *    // The field `value` must not be equal to any of the specified values.
+     *    MyEnum value = 1 [(buf.validate.field).enum = { not_in: [1, 2]}];
+     *  }
+     *  ```
+     *
+     */
+    notIn: number[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  enum MyEnum {
+     *    MY_ENUM_UNSPECIFIED = 0;
+     *    MY_ENUM_VALUE1 = 1;
+     *    MY_ENUM_VALUE2 = 2;
+     *  }
+     *
+     *  message MyMessage {
+     *      (buf.validate.field).enum.example = 1,
+     *      (buf.validate.field).enum.example = 2
+     *  }
+     *  ```
+     *
+     */
+    example: number[];
+}
+export declare const EnumRules: MessageFns<EnumRules, "buf.validate.EnumRules">;
+/**
+ *  RepeatedRules describe the constraints applied to `repeated` values.
+ *
+ */
+export interface RepeatedRules {
+    $type: "buf.validate.RepeatedRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `min_items` requires that this field must contain at least the specified
+     *  minimum number of items.
+     *
+     *  Note that `min_items = 1` is equivalent to setting a field as `required`.
+     *
+     *  ```proto
+     *  message MyRepeated {
+     *    // value must contain at least  2 items
+     *    repeated string value = 1 [(buf.validate.field).repeated.min_items = 2];
+     *  }
+     *  ```
+     *
+     */
+    minItems?: Long | undefined;
+    /**
+     *  `max_items` denotes that this field must not exceed a
+     *  certain number of items as the upper limit. If the field contains more
+     *  items than specified, an error message will be generated, requiring the
+     *  field to maintain no more than the specified number of items.
+     *
+     *  ```proto
+     *  message MyRepeated {
+     *    // value must contain no more than 3 item(s)
+     *    repeated string value = 1 [(buf.validate.field).repeated.max_items = 3];
+     *  }
+     *  ```
+     *
+     */
+    maxItems?: Long | undefined;
+    /**
+     *  `unique` indicates that all elements in this field must
+     *  be unique. This constraint is strictly applicable to scalar and enum
+     *  types, with message types not being supported.
+     *
+     *  ```proto
+     *  message MyRepeated {
+     *    // repeated value must contain unique items
+     *    repeated string value = 1 [(buf.validate.field).repeated.unique = true];
+     *  }
+     *  ```
+     *
+     */
+    unique?: boolean | undefined;
+    /**
+     *  `items` details the constraints to be applied to each item
+     *  in the field. Even for repeated message fields, validation is executed
+     *  against each item unless skip is explicitly specified.
+     *
+     *  ```proto
+     *  message MyRepeated {
+     *    // The items in the field `value` must follow the specified constraints.
+     *    repeated string value = 1 [(buf.validate.field).repeated.items = {
+     *      string: {
+     *        min_len: 3
+     *        max_len: 10
+     *      }
+     *    }];
+     *  }
+     *  ```
+     *
+     */
+    items?: FieldConstraints | undefined;
+}
+export declare const RepeatedRules: MessageFns<RepeatedRules, "buf.validate.RepeatedRules">;
+/**
+ *  MapRules describe the constraints applied to `map` values.
+ *
+ */
+export interface MapRules {
+    $type: "buf.validate.MapRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     * Specifies the minimum number of key-value pairs allowed. If the field has
+     *  fewer key-value pairs than specified, an error message is generated.
+     *
+     *  ```proto
+     *  message MyMap {
+     *    // The field `value` must have at least 2 key-value pairs.
+     *    map<string, string> value = 1 [(buf.validate.field).map.min_pairs = 2];
+     *  }
+     *  ```
+     *
+     */
+    minPairs?: Long | undefined;
+    /**
+     * Specifies the maximum number of key-value pairs allowed. If the field has
+     *  more key-value pairs than specified, an error message is generated.
+     *
+     *  ```proto
+     *  message MyMap {
+     *    // The field `value` must have at most 3 key-value pairs.
+     *    map<string, string> value = 1 [(buf.validate.field).map.max_pairs = 3];
+     *  }
+     *  ```
+     *
+     */
+    maxPairs?: Long | undefined;
+    /**
+     * Specifies the constraints to be applied to each key in the field.
+     *
+     *  ```proto
+     *  message MyMap {
+     *    // The keys in the field `value` must follow the specified constraints.
+     *    map<string, string> value = 1 [(buf.validate.field).map.keys = {
+     *      string: {
+     *        min_len: 3
+     *        max_len: 10
+     *      }
+     *    }];
+     *  }
+     *  ```
+     *
+     */
+    keys?: FieldConstraints | undefined;
+    /**
+     * Specifies the constraints to be applied to the value of each key in the
+     *  field. Message values will still have their validations evaluated unless
+     * skip is specified here.
+     *
+     *  ```proto
+     *  message MyMap {
+     *    // The values in the field `value` must follow the specified constraints.
+     *    map<string, string> value = 1 [(buf.validate.field).map.values = {
+     *      string: {
+     *        min_len: 5
+     *        max_len: 20
+     *      }
+     *    }];
+     *  }
+     *  ```
+     *
+     */
+    values?: FieldConstraints | undefined;
+}
+export declare const MapRules: MessageFns<MapRules, "buf.validate.MapRules">;
+/**
+ *  AnyRules describe constraints applied exclusively to the `google.protobuf.Any` well-known type.
+ *
+ */
+export interface AnyRules {
+    $type: "buf.validate.AnyRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `in` requires the field's `type_url` to be equal to one of the
+     * specified values. If it doesn't match any of the specified values, an error
+     *  message is generated.
+     *
+     *  ```proto
+     *  message MyAny {
+     *    //  The `value` field must have a `type_url` equal to one of the specified values.
+     *    google.protobuf.Any value = 1 [(buf.validate.field).any.in = ["type.googleapis.com/MyType1", "type.googleapis.com/MyType2"]];
+     *  }
+     *  ```
+     *
+     */
+    in: string[];
+    /**
+     *  requires the field's type_url to be not equal to any of the specified values. If it matches any of the specified values, an error message is generated.
+     *
+     *  ```proto
+     *  message MyAny {
+     *    // The field `value` must not have a `type_url` equal to any of the specified values.
+     *    google.protobuf.Any value = 1 [(buf.validate.field).any.not_in = ["type.googleapis.com/ForbiddenType1", "type.googleapis.com/ForbiddenType2"]];
+     *  }
+     *  ```
+     *
+     */
+    notIn: string[];
+}
+export declare const AnyRules: MessageFns<AnyRules, "buf.validate.AnyRules">;
+/**
+ *  DurationRules describe the constraints applied exclusively to the `google.protobuf.Duration` well-known type.
+ *
+ */
+export interface DurationRules {
+    $type: "buf.validate.DurationRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `const` dictates that the field must match the specified value of the `google.protobuf.Duration` type exactly.
+     *  If the field's value deviates from the specified value, an error message
+     *  will be generated.
+     *
+     *  ```proto
+     *  message MyDuration {
+     *    // value must equal 5s
+     *    google.protobuf.Duration value = 1 [(buf.validate.field).duration.const = "5s"];
+     *  }
+     *  ```
+     *
+     */
+    const?: Duration | undefined;
+    /**
+     *  `in` asserts that the field must be equal to one of the specified values of the `google.protobuf.Duration` type.
+     *  If the field's value doesn't correspond to any of the specified values,
+     *  an error message will be generated.
+     *
+     *  ```proto
+     *  message MyDuration {
+     *    // value must be in list [1s, 2s, 3s]
+     *    google.protobuf.Duration value = 1 [(buf.validate.field).duration.in = ["1s", "2s", "3s"]];
+     *  }
+     *  ```
+     *
+     */
+    in: Duration[];
+    /**
+     *  `not_in` denotes that the field must not be equal to
+     *  any of the specified values of the `google.protobuf.Duration` type.
+     *  If the field's value matches any of these values, an error message will be
+     *  generated.
+     *
+     *  ```proto
+     *  message MyDuration {
+     *    // value must not be in list [1s, 2s, 3s]
+     *    google.protobuf.Duration value = 1 [(buf.validate.field).duration.not_in = ["1s", "2s", "3s"]];
+     *  }
+     *  ```
+     *
+     */
+    notIn: Duration[];
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyDuration {
+     *    google.protobuf.Duration value = 1 [
+     *      (buf.validate.field).duration.example = { seconds: 1 },
+     *      (buf.validate.field).duration.example = { seconds: 2 },
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: Duration[];
+    lessThan?: {
+        $case: "lt";
+        lt: Duration;
+    } | {
+        $case: "lte";
+        lte: Duration;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: Duration;
+    } | {
+        $case: "gte";
+        gte: Duration;
+    } | undefined;
+}
+export declare const DurationRules: MessageFns<DurationRules, "buf.validate.DurationRules">;
+/**
+ *  TimestampRules describe the constraints applied exclusively to the `google.protobuf.Timestamp` well-known type.
+ *
+ */
+export interface TimestampRules {
+    $type: "buf.validate.TimestampRules";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `const` dictates that this field, of the `google.protobuf.Timestamp` type, must exactly match the specified value. If the field value doesn't correspond to the specified timestamp, an error message will be generated.
+     *
+     *  ```proto
+     *  message MyTimestamp {
+     *    // value must equal 2023-05-03T10:00:00Z
+     *    google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.const = {seconds: 1727998800}];
+     *  }
+     *  ```
+     *
+     */
+    const?: Dayjs | undefined;
+    /**
+     *  `within` specifies that this field, of the `google.protobuf.Timestamp` type, must be within the specified duration of the current time. If the field value isn't within the duration, an error message is generated.
+     *
+     *  ```proto
+     *  message MyTimestamp {
+     *    // value must be within 1 hour of now
+     *    google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.within = {seconds: 3600}];
+     *  }
+     *  ```
+     *
+     */
+    within?: Duration | undefined;
+    /**
+     *  `example` specifies values that the field may have. These values SHOULD
+     *  conform to other constraints. `example` values will not impact validation
+     *  but may be used as helpful guidance on how to populate the given field.
+     *
+     *  ```proto
+     *  message MyTimestamp {
+     *    google.protobuf.Timestamp value = 1 [
+     *      (buf.validate.field).timestamp.example = { seconds: 1672444800 },
+     *      (buf.validate.field).timestamp.example = { seconds: 1672531200 },
+     *    ];
+     *  }
+     *  ```
+     *
+     */
+    example: Dayjs[];
+    lessThan?: {
+        $case: "lt";
+        lt: Dayjs;
+    } | {
+        $case: "lte";
+        lte: Dayjs;
+    } | {
+        $case: "ltNow";
+        ltNow: boolean;
+    } | undefined;
+    greaterThan?: {
+        $case: "gt";
+        gt: Dayjs;
+    } | {
+        $case: "gte";
+        gte: Dayjs;
+    } | {
+        $case: "gtNow";
+        gtNow: boolean;
+    } | undefined;
+}
+export declare const TimestampRules: MessageFns<TimestampRules, "buf.validate.TimestampRules">;
+/**
+ *  `Violations` is a collection of `Violation` messages. This message type is returned by
+ *  protovalidate when a proto message fails to meet the requirements set by the `Constraint` validation rules.
+ *  Each individual violation is represented by a `Violation` message.
+ *
+ */
+export interface Violations {
+    $type: "buf.validate.Violations";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `violations` is a repeated field that contains all the `Violation` messages corresponding to the violations detected.
+     *
+     */
+    violations: Violation[];
+}
+export declare const Violations: MessageFns<Violations, "buf.validate.Violations">;
+/**
+ *  `Violation` represents a single instance where a validation rule, expressed
+ *  as a `Constraint`, was not met. It provides information about the field that
+ *  caused the violation, the specific constraint that wasn't fulfilled, and a
+ *  human-readable error message.
+ *
+ *  ```json
+ *  {
+ *    "fieldPath": "bar",
+ *    "constraintId": "foo.bar",
+ *    "message": "bar must be greater than 0"
+ *  }
+ *  ```
+ *
+ */
+export interface Violation {
+    $type: "buf.validate.Violation";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `field` is a machine-readable path to the field that failed validation.
+     *  This could be a nested field, in which case the path will include all the parent fields leading to the actual field that caused the violation.
+     *
+     *  For example, consider the following message:
+     *
+     *  ```proto
+     *  message Message {
+     *    bool a = 1 [(buf.validate.field).required = true];
+     *  }
+     *  ```
+     *
+     *  It could produce the following violation:
+     *
+     *  ```textproto
+     *  violation {
+     *    field { element { field_number: 1, field_name: "a", field_type: 8 } }
+     *    ...
+     *  }
+     *  ```
+     *
+     */
+    field?: FieldPath | undefined;
+    /**
+     *  `rule` is a machine-readable path that points to the specific constraint rule that failed validation.
+     *  This will be a nested field starting from the FieldConstraints of the field that failed validation.
+     *  For custom constraints, this will provide the path of the constraint, e.g. `cel[0]`.
+     *
+     *  For example, consider the following message:
+     *
+     *  ```proto
+     *  message Message {
+     *    bool a = 1 [(buf.validate.field).required = true];
+     *    bool b = 2 [(buf.validate.field).cel = {
+     *      id: "custom_constraint",
+     *      expression: "!this ? 'b must be true': ''"
+     *    }]
+     *  }
+     *  ```
+     *
+     *  It could produce the following violations:
+     *
+     *  ```textproto
+     *  violation {
+     *    rule { element { field_number: 25, field_name: "required", field_type: 8 } }
+     *    ...
+     *  }
+     *  violation {
+     *    rule { element { field_number: 23, field_name: "cel", field_type: 11, index: 0 } }
+     *    ...
+     *  }
+     *  ```
+     *
+     */
+    rule?: FieldPath | undefined;
+    /**
+     *  `field_path` is a human-readable identifier that points to the specific field that failed the validation.
+     *  This could be a nested field, in which case the path will include all the parent fields leading to the actual field that caused the violation.
+     *
+     *  Deprecated: use the `field` instead.
+     *
+     * @deprecated Deprecated.
+     */
+    fieldPath?: string | undefined;
+    /**
+     *  `constraint_id` is the unique identifier of the `Constraint` that was not fulfilled.
+     *  This is the same `id` that was specified in the `Constraint` message, allowing easy tracing of which rule was violated.
+     *
+     */
+    constraintId?: string | undefined;
+    /**
+     *  `message` is a human-readable error message that describes the nature of the violation.
+     *  This can be the default error message from the violated `Constraint`, or it can be a custom message that gives more context about the violation.
+     *
+     */
+    message?: string | undefined;
+    /**
+     *  `for_key` indicates whether the violation was caused by a map key, rather than a value.
+     *
+     */
+    forKey?: boolean | undefined;
+}
+export declare const Violation: MessageFns<Violation, "buf.validate.Violation">;
+/**
+ *  `FieldPath` provides a path to a nested protobuf field.
+ *
+ *  This message provides enough information to render a dotted field path even without protobuf descriptors.
+ *  It also provides enough information to resolve a nested field through unknown wire data.
+ *
+ */
+export interface FieldPath {
+    $type: "buf.validate.FieldPath";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `elements` contains each element of the path, starting from the root and recursing downward.
+     *
+     */
+    elements: FieldPathElement[];
+}
+export declare const FieldPath: MessageFns<FieldPath, "buf.validate.FieldPath">;
+/**
+ *  `FieldPathElement` provides enough information to nest through a single protobuf field.
+ *
+ *  If the selected field is a map or repeated field, the `subscript` value selects a specific element from it.
+ *  A path that refers to a value nested under a map key or repeated field index will have a `subscript` value.
+ *  The `field_type` field allows unambiguous resolution of a field even if descriptors are not available.
+ *
+ */
+export interface FieldPathElement {
+    $type: "buf.validate.FieldPathElement";
+    [unknownFieldsSymbol]?: Uint8Array | undefined;
+    [customJson]?: () => unknown;
+    /**
+     *  `field_number` is the field number this path element refers to.
+     *
+     */
+    fieldNumber?: number | undefined;
+    /**
+     *  `field_name` contains the field name this path element refers to.
+     *  This can be used to display a human-readable path even if the field number is unknown.
+     *
+     */
+    fieldName?: string | undefined;
+    /**
+     *  `field_type` specifies the type of this field. When using reflection, this value is not needed.
+     *
+     *  This value is provided to make it possible to traverse unknown fields through wire data.
+     *  When traversing wire data, be mindful of both packed[1] and delimited[2] encoding schemes.
+     *
+     *  [1]: https://protobuf.dev/programming-guides/encoding/#packed
+     *  [2]: https://protobuf.dev/programming-guides/encoding/#groups
+     *
+     *  N.B.: Although groups are deprecated, the corresponding delimited encoding scheme is not, and
+     *  can be explicitly used in Protocol Buffers 2023 Edition.
+     *
+     */
+    fieldType?: FieldDescriptorProto_Type | undefined;
+    /**
+     *  `key_type` specifies the map key type of this field. This value is useful when traversing
+     *  unknown fields through wire data: specifically, it allows handling the differences between
+     *  different integer encodings.
+     *
+     */
+    keyType?: FieldDescriptorProto_Type | undefined;
+    /**
+     *  `value_type` specifies map value type of this field. This is useful if you want to display a
+     *  value inside unknown fields through wire data.
+     *
+     */
+    valueType?: FieldDescriptorProto_Type | undefined;
+    /**
+     *  `subscript` contains a repeated index or map key, if this path element nests into a repeated or map field.
+     *
+     */
+    subscript?: {
+        $case: "index";
+        index: Long;
+    } | {
+        $case: "boolKey";
+        boolKey: boolean;
+    } | {
+        $case: "intKey";
+        intKey: Long;
+    } | {
+        $case: "uintKey";
+        uintKey: Long;
+    } | {
+        $case: "stringKey";
+        stringKey: string;
+    } | undefined;
+}
+export declare const FieldPathElement: MessageFns<FieldPathElement, "buf.validate.FieldPathElement">;
+import "../../google/protobuf/index";
+declare module '../../google/protobuf/index' {
+    interface MessageOptions {
+        message?: MessageConstraints;
+    }
+}
+declare module '../../google/protobuf/index' {
+    interface OneofOptions {
+        oneof?: OneofConstraints;
+    }
+}
+declare module '../../google/protobuf/index' {
+    interface FieldOptions {
+        field?: FieldConstraints;
+    }
+}
+declare module '../../google/protobuf/index' {
+    interface FieldOptions {
+        predefined?: PredefinedConstraints;
+    }
+}
+export {};
+//# sourceMappingURL=index.d.ts.map