{"version":3,"file":"283a012.js","mappings":"inBAIA,MAAM,KAAgB,MAAiB,EAC1B,EAAgB,GAAY,CACvC,MAAM,EAAU,EAAc,OAAO,OAC/B,KAAY,KAAuB,CAAE,SAAQ,CAAC,EACpD,SAAO,MAAa,EAAS,CAAS,CACxC,EACa,EAAY,MAAO,EAAiB,IAAY,CAC3D,IAAI,EACJ,MAAM,EAAS,CACb,MAAG,KAAkB,EACrB,SAAW,GAAY,CACrB,EAAkB,CACpB,CACF,EACA,GAAI,CACF,MAAM,EAAW,MAAM,EAAgB,EAAS,CAAM,EACtD,SAAO,MAAgB,EAAU,CAAe,CAClD,OAAS,EAAG,CACV,SAAO,MAAc,EAAG,CAAe,CACzC,CACF,EACa,EAA4B,MAAO,EAAiB,EAAS,IAAY,CACpF,MAAM,KAAS,KAAkB,CAAO,EACxC,GAAI,CACF,MAAM,EAAW,MAAM,EAAgB,EAAS,CAAM,EACtD,SAAO,MAAgB,CAAQ,CACjC,OAAS,EAAG,CACV,SAAO,MAAc,CAAC,CACxB,CACF,C,oHCNO,MAAMA,KACX,KAAS,6mnEAA8mnE,CAAC,KAAiC,IAA+B,GAA8B,CAAC,EAuD5snEC,KACX,KAAYD,EAA4B,CAAC,EAmD9BE,KACX,KAAYF,EAA4B,CAAC,EAqC9BG,KACX,KAAYH,EAA4B,CAAC,EAqO9BI,KACX,KAAYJ,EAA4B,CAAC,EAkC9BK,KACX,KAAYL,EAA4B,CAAC,EAqL9BM,KACX,KAAYN,EAA4B,CAAC,EAqL9BO,KACX,KAAYP,EAA4B,CAAC,EA6K9BQ,KACX,KAAYR,EAA4B,CAAC,EA6K9BS,KACX,KAAYT,EAA4B,CAAC,EA6K9BU,KACX,KAAYV,EAA4B,CAAC,EA6K9BW,KACX,KAAYX,EAA4B,EAAE,EA4K/BY,KACX,KAAYZ,EAA4B,EAAE,EA4K/Ba,KACX,KAAYb,EAA4B,EAAE,EA4K/Bc,KACX,KAAYd,EAA4B,EAAE,EA4K/Be,KACX,KAAYf,EAA4B,EAAE,EA4K/BgB,KACX,KAAYhB,EAA4B,EAAE,EA4K/BiB,KACX,KAAYjB,EAA4B,EAAE,EA+C/BkB,KACX,KAAYlB,EAA4B,EAAE,EA+lB/BmB,KACX,KAAYnB,EAA4B,EAAE,EAwP/BoB,KACX,KAAYpB,EAA4B,EAAE,EAyH/BqB,KACX,KAAYrB,EAA4B,EAAE,EAoF/BsB,KACX,KAAYtB,EAA4B,EAAE,EAmF/BuB,KACX,KAAYvB,EAA4B,EAAE,EA2C/BwB,KACX,KAAYxB,EAA4B,EAAE,EA8K/ByB,KACX,KAAYzB,EAA4B,EAAE,EAsK/B0B,KACX,KAAY1B,EAA4B,EAAE,EAsB/B2B,KACX,KAAY3B,EAA4B,EAAE,EAuD/B4B,KACX,KAAY5B,EAA4B,EAAE,EAQrC,IAAK6B,GAAAA,IAkCVA,EAAAA,EAAA,YAAc,CAAC,EAAf,cA2CAA,EAAAA,EAAA,eAAiB,CAAC,EAAlB,iBA8DAA,EAAAA,EAAA,iBAAmB,CAAC,EAApB,mBAmBAA,EAAAA,EAAA,OAAS,CAAC,EAAV,SAQAA,EAAAA,EAAA,MAAQ,CAAC,EAAT,QAQAA,EAAAA,EAAA,QAAU,CAAC,EAAX,UA9KUA,IAAAA,GAAA,IAoLL,MAAMC,KACX,KAAS9B,EAA4B,CAAC,EAOjC,IAAK+B,GAAAA,IAIVA,EAAAA,EAAA,YAAc,CAAC,EAAf,cAOAA,EAAAA,EAAA,iBAAmB,CAAC,EAApB,mBAOAA,EAAAA,EAAA,kBAAoB,CAAC,EAArB,oBAlBUA,IAAAA,GAAA,IAwBL,MAAMC,KACX,KAAShC,EAA4B,CAAC,EAQ3BiC,KACX,KAAQjC,EAA4B,CAAC,EAQ1BkC,KACX,KAAQlC,EAA4B,CAAC,EAQ1BmC,KACX,KAAQnC,EAA4B,CAAC,EAsB1BoC,KACX,KAAQpC,EAA4B,CAAC,C","sources":["webpack://nuxt-app/","webpack://nuxt-app/./app/pb/buf/validate/validate_pb.ts"],"sourcesContent":[null,"// Copyright 2023 Buf Technologies, Inc.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// @generated by protoc-gen-es v2.2.0 with parameter \"target=ts\"\n// @generated from file buf/validate/validate.proto (package buf.validate, syntax proto2)\n/* eslint-disable */\n\nimport type { GenEnum, GenExtension, GenFile, GenMessage } from \"@bufbuild/protobuf/codegenv1\";\nimport { enumDesc, extDesc, fileDesc, messageDesc } from \"@bufbuild/protobuf/codegenv1\";\nimport type { Duration, FieldOptions, MessageOptions, OneofOptions, Timestamp } from \"@bufbuild/protobuf/wkt\";\nimport { file_google_protobuf_descriptor, file_google_protobuf_duration, file_google_protobuf_timestamp } from \"@bufbuild/protobuf/wkt\";\nimport type { Message } from \"@bufbuild/protobuf\";\n\n/**\n * Describes the file buf/validate/validate.proto.\n */\nexport const file_buf_validate_validate: GenFile = /*@__PURE__*/\n fileDesc(\"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\", [file_google_protobuf_descriptor, file_google_protobuf_duration, file_google_protobuf_timestamp]);\n\n/**\n * `Constraint` represents a validation rule written in the Common Expression\n * Language (CEL) syntax. Each Constraint includes a unique identifier, an\n * optional error message, and the CEL expression to evaluate. For more\n * information on CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).\n *\n * ```proto\n * message Foo {\n * option (buf.validate.message).cel = {\n * id: \"foo.bar\"\n * message: \"bar must be greater than 0\"\n * expression: \"this.bar > 0\"\n * };\n * int32 bar = 1;\n * }\n * ```\n *\n * @generated from message buf.validate.Constraint\n */\nexport type Constraint = Message<\"buf.validate.Constraint\"> & {\n /**\n * `id` is a string that serves as a machine-readable name for this Constraint.\n * It should be unique within its scope, which could be either a message or a field.\n *\n * @generated from field: optional string id = 1;\n */\n id: string;\n\n /**\n * `message` is an optional field that provides a human-readable error message\n * for this Constraint when the CEL expression evaluates to false. If a\n * non-empty message is provided, any strings resulting from the CEL\n * expression evaluation are ignored.\n *\n * @generated from field: optional string message = 2;\n */\n message: string;\n\n /**\n * `expression` is the actual CEL expression that will be evaluated for\n * validation. This string must resolve to either a boolean or a string\n * value. If the expression evaluates to false or a non-empty string, the\n * validation is considered failed, and the message is rejected.\n *\n * @generated from field: optional string expression = 3;\n */\n expression: string;\n};\n\n/**\n * Describes the message buf.validate.Constraint.\n * Use `create(ConstraintSchema)` to create a new message.\n */\nexport const ConstraintSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 0);\n\n/**\n * MessageConstraints represents validation rules that are applied to the entire message.\n * It includes disabling options and a list of Constraint messages representing Common Expression Language (CEL) validation rules.\n *\n * @generated from message buf.validate.MessageConstraints\n */\nexport type MessageConstraints = Message<\"buf.validate.MessageConstraints\"> & {\n /**\n * `disabled` is a boolean flag that, when set to true, nullifies any validation rules for this message.\n * This includes any fields within the message that would otherwise support validation.\n *\n * ```proto\n * message MyMessage {\n * // validation will be bypassed for this message\n * option (buf.validate.message).disabled = true;\n * }\n * ```\n *\n * @generated from field: optional bool disabled = 1;\n */\n disabled: boolean;\n\n /**\n * `cel` is a repeated field of type Constraint. Each Constraint specifies a validation rule to be applied to this message.\n * These constraints are written in Common Expression Language (CEL) syntax. For more information on\n * CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).\n *\n *\n * ```proto\n * message MyMessage {\n * // The field `foo` must be greater than 42.\n * option (buf.validate.message).cel = {\n * id: \"my_message.value\",\n * message: \"value must be greater than 42\",\n * expression: \"this.foo > 42\",\n * };\n * optional int32 foo = 1;\n * }\n * ```\n *\n * @generated from field: repeated buf.validate.Constraint cel = 3;\n */\n cel: Constraint[];\n};\n\n/**\n * Describes the message buf.validate.MessageConstraints.\n * Use `create(MessageConstraintsSchema)` to create a new message.\n */\nexport const MessageConstraintsSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 1);\n\n/**\n * The `OneofConstraints` message type enables you to manage constraints for\n * oneof fields in your protobuf messages.\n *\n * @generated from message buf.validate.OneofConstraints\n */\nexport type OneofConstraints = Message<\"buf.validate.OneofConstraints\"> & {\n /**\n * If `required` is true, exactly one field of the oneof must be present. A\n * validation error is returned if no fields in the oneof are present. The\n * field itself may still be a default value; further constraints\n * should be placed on the fields themselves to ensure they are valid values,\n * such as `min_len` or `gt`.\n *\n * ```proto\n * message MyMessage {\n * oneof value {\n * // Either `a` or `b` must be set. If `a` is set, it must also be\n * // non-empty; whereas if `b` is set, it can still be an empty string.\n * option (buf.validate.oneof).required = true;\n * string a = 1 [(buf.validate.field).string.min_len = 1];\n * string b = 2;\n * }\n * }\n * ```\n *\n * @generated from field: optional bool required = 1;\n */\n required: boolean;\n};\n\n/**\n * Describes the message buf.validate.OneofConstraints.\n * Use `create(OneofConstraintsSchema)` to create a new message.\n */\nexport const OneofConstraintsSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 2);\n\n/**\n * FieldConstraints encapsulates the rules for each type of field. Depending on\n * the field, the correct set should be used to ensure proper validations.\n *\n * @generated from message buf.validate.FieldConstraints\n */\nexport type FieldConstraints = Message<\"buf.validate.FieldConstraints\"> & {\n /**\n * `cel` is a repeated field used to represent a textual expression\n * in the Common Expression Language (CEL) syntax. For more information on\n * CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).\n *\n * ```proto\n * message MyMessage {\n * // The field `value` must be greater than 42.\n * optional int32 value = 1 [(buf.validate.field).cel = {\n * id: \"my_message.value\",\n * message: \"value must be greater than 42\",\n * expression: \"this > 42\",\n * }];\n * }\n * ```\n *\n * @generated from field: repeated buf.validate.Constraint cel = 23;\n */\n cel: Constraint[];\n\n /**\n * If `required` is true, the field must be populated. A populated field can be\n * described as \"serialized in the wire format,\" which includes:\n *\n * - the following \"nullable\" fields must be explicitly set to be considered populated:\n * - singular message fields (whose fields may be unpopulated/default values)\n * - member fields of a oneof (may be their default value)\n * - proto3 optional fields (may be their default value)\n * - proto2 scalar fields (both optional and required)\n * - proto3 scalar fields must be non-zero to be considered populated\n * - repeated and map fields must be non-empty to be considered populated\n *\n * ```proto\n * message MyMessage {\n * // The field `value` must be set to a non-null value.\n * optional MyOtherMessage value = 1 [(buf.validate.field).required = true];\n * }\n * ```\n *\n * @generated from field: optional bool required = 25;\n */\n required: boolean;\n\n /**\n * Skip validation on the field if its value matches the specified criteria.\n * See Ignore enum for details.\n *\n * ```proto\n * message UpdateRequest {\n * // The uri rule only applies if the field is populated and not an empty\n * // string.\n * optional string url = 1 [\n * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE,\n * (buf.validate.field).string.uri = true,\n * ];\n * }\n * ```\n *\n * @generated from field: optional buf.validate.Ignore ignore = 27;\n */\n ignore: Ignore;\n\n /**\n * @generated from oneof buf.validate.FieldConstraints.type\n */\n type: {\n /**\n * Scalar Field Types\n *\n * @generated from field: buf.validate.FloatRules float = 1;\n */\n value: FloatRules;\n case: \"float\";\n } | {\n /**\n * @generated from field: buf.validate.DoubleRules double = 2;\n */\n value: DoubleRules;\n case: \"double\";\n } | {\n /**\n * @generated from field: buf.validate.Int32Rules int32 = 3;\n */\n value: Int32Rules;\n case: \"int32\";\n } | {\n /**\n * @generated from field: buf.validate.Int64Rules int64 = 4;\n */\n value: Int64Rules;\n case: \"int64\";\n } | {\n /**\n * @generated from field: buf.validate.UInt32Rules uint32 = 5;\n */\n value: UInt32Rules;\n case: \"uint32\";\n } | {\n /**\n * @generated from field: buf.validate.UInt64Rules uint64 = 6;\n */\n value: UInt64Rules;\n case: \"uint64\";\n } | {\n /**\n * @generated from field: buf.validate.SInt32Rules sint32 = 7;\n */\n value: SInt32Rules;\n case: \"sint32\";\n } | {\n /**\n * @generated from field: buf.validate.SInt64Rules sint64 = 8;\n */\n value: SInt64Rules;\n case: \"sint64\";\n } | {\n /**\n * @generated from field: buf.validate.Fixed32Rules fixed32 = 9;\n */\n value: Fixed32Rules;\n case: \"fixed32\";\n } | {\n /**\n * @generated from field: buf.validate.Fixed64Rules fixed64 = 10;\n */\n value: Fixed64Rules;\n case: \"fixed64\";\n } | {\n /**\n * @generated from field: buf.validate.SFixed32Rules sfixed32 = 11;\n */\n value: SFixed32Rules;\n case: \"sfixed32\";\n } | {\n /**\n * @generated from field: buf.validate.SFixed64Rules sfixed64 = 12;\n */\n value: SFixed64Rules;\n case: \"sfixed64\";\n } | {\n /**\n * @generated from field: buf.validate.BoolRules bool = 13;\n */\n value: BoolRules;\n case: \"bool\";\n } | {\n /**\n * @generated from field: buf.validate.StringRules string = 14;\n */\n value: StringRules;\n case: \"string\";\n } | {\n /**\n * @generated from field: buf.validate.BytesRules bytes = 15;\n */\n value: BytesRules;\n case: \"bytes\";\n } | {\n /**\n * Complex Field Types\n *\n * @generated from field: buf.validate.EnumRules enum = 16;\n */\n value: EnumRules;\n case: \"enum\";\n } | {\n /**\n * @generated from field: buf.validate.RepeatedRules repeated = 18;\n */\n value: RepeatedRules;\n case: \"repeated\";\n } | {\n /**\n * @generated from field: buf.validate.MapRules map = 19;\n */\n value: MapRules;\n case: \"map\";\n } | {\n /**\n * Well-Known Field Types\n *\n * @generated from field: buf.validate.AnyRules any = 20;\n */\n value: AnyRules;\n case: \"any\";\n } | {\n /**\n * @generated from field: buf.validate.DurationRules duration = 21;\n */\n value: DurationRules;\n case: \"duration\";\n } | {\n /**\n * @generated from field: buf.validate.TimestampRules timestamp = 22;\n */\n value: TimestampRules;\n case: \"timestamp\";\n } | { case: undefined; value?: undefined };\n\n /**\n * DEPRECATED: use ignore=IGNORE_ALWAYS instead. TODO: remove this field pre-v1.\n *\n * @generated from field: optional bool skipped = 24 [deprecated = true];\n * @deprecated\n */\n skipped: boolean;\n\n /**\n * DEPRECATED: use ignore=IGNORE_IF_UNPOPULATED instead. TODO: remove this field pre-v1.\n *\n * @generated from field: optional bool ignore_empty = 26 [deprecated = true];\n * @deprecated\n */\n ignoreEmpty: boolean;\n};\n\n/**\n * Describes the message buf.validate.FieldConstraints.\n * Use `create(FieldConstraintsSchema)` to create a new message.\n */\nexport const FieldConstraintsSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 3);\n\n/**\n * PredefinedConstraints are custom constraints that can be re-used with\n * multiple fields.\n *\n * @generated from message buf.validate.PredefinedConstraints\n */\nexport type PredefinedConstraints = Message<\"buf.validate.PredefinedConstraints\"> & {\n /**\n * `cel` is a repeated field used to represent a textual expression\n * in the Common Expression Language (CEL) syntax. For more information on\n * CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).\n *\n * ```proto\n * message MyMessage {\n * // The field `value` must be greater than 42.\n * optional int32 value = 1 [(buf.validate.predefined).cel = {\n * id: \"my_message.value\",\n * message: \"value must be greater than 42\",\n * expression: \"this > 42\",\n * }];\n * }\n * ```\n *\n * @generated from field: repeated buf.validate.Constraint cel = 1;\n */\n cel: Constraint[];\n};\n\n/**\n * Describes the message buf.validate.PredefinedConstraints.\n * Use `create(PredefinedConstraintsSchema)` to create a new message.\n */\nexport const PredefinedConstraintsSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 4);\n\n/**\n * FloatRules describes the constraints applied to `float` values. These\n * rules may also be applied to the `google.protobuf.FloatValue` Well-Known-Type.\n *\n * @generated from message buf.validate.FloatRules\n */\nexport type FloatRules = Message<\"buf.validate.FloatRules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyFloat {\n * // value must equal 42.0\n * float value = 1 [(buf.validate.field).float.const = 42.0];\n * }\n * ```\n *\n * @generated from field: optional float const = 1;\n */\n const: number;\n\n /**\n * @generated from oneof buf.validate.FloatRules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field <\n * value). If the field value is equal to or greater than the specified value,\n * an error message is generated.\n *\n * ```proto\n * message MyFloat {\n * // value must be less than 10.0\n * float value = 1 [(buf.validate.field).float.lt = 10.0];\n * }\n * ```\n *\n * @generated from field: float lt = 2;\n */\n value: number;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MyFloat {\n * // value must be less than or equal to 10.0\n * float value = 1 [(buf.validate.field).float.lte = 10.0];\n * }\n * ```\n *\n * @generated from field: float lte = 3;\n */\n value: number;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.FloatRules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyFloat {\n * // value must be greater than 5.0 [float.gt]\n * float value = 1 [(buf.validate.field).float.gt = 5.0];\n *\n * // value must be greater than 5 and less than 10.0 [float.gt_lt]\n * float other_value = 2 [(buf.validate.field).float = { gt: 5.0, lt: 10.0 }];\n *\n * // value must be greater than 10 or less than 5.0 [float.gt_lt_exclusive]\n * float another_value = 3 [(buf.validate.field).float = { gt: 10.0, lt: 5.0 }];\n * }\n * ```\n *\n * @generated from field: float gt = 4;\n */\n value: number;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyFloat {\n * // value must be greater than or equal to 5.0 [float.gte]\n * float value = 1 [(buf.validate.field).float.gte = 5.0];\n *\n * // value must be greater than or equal to 5.0 and less than 10.0 [float.gte_lt]\n * float other_value = 2 [(buf.validate.field).float = { gte: 5.0, lt: 10.0 }];\n *\n * // value must be greater than or equal to 10.0 or less than 5.0 [float.gte_lt_exclusive]\n * float another_value = 3 [(buf.validate.field).float = { gte: 10.0, lt: 5.0 }];\n * }\n * ```\n *\n * @generated from field: float gte = 5;\n */\n value: number;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message\n * is generated.\n *\n * ```proto\n * message MyFloat {\n * // value must be in list [1.0, 2.0, 3.0]\n * repeated float value = 1 (buf.validate.field).float = { in: [1.0, 2.0, 3.0] };\n * }\n * ```\n *\n * @generated from field: repeated float in = 6;\n */\n in: number[];\n\n /**\n * `in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MyFloat {\n * // value must not be in list [1.0, 2.0, 3.0]\n * repeated float value = 1 (buf.validate.field).float = { not_in: [1.0, 2.0, 3.0] };\n * }\n * ```\n *\n * @generated from field: repeated float not_in = 7;\n */\n notIn: number[];\n\n /**\n * `finite` requires the field value to be finite. If the field value is\n * infinite or NaN, an error message is generated.\n *\n * @generated from field: optional bool finite = 8;\n */\n finite: boolean;\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyFloat {\n * float value = 1 [\n * (buf.validate.field).float.example = 1.0,\n * (buf.validate.field).float.example = \"Infinity\"\n * ];\n * }\n * ```\n *\n * @generated from field: repeated float example = 9;\n */\n example: number[];\n};\n\n/**\n * Describes the message buf.validate.FloatRules.\n * Use `create(FloatRulesSchema)` to create a new message.\n */\nexport const FloatRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 5);\n\n/**\n * DoubleRules describes the constraints applied to `double` values. These\n * rules may also be applied to the `google.protobuf.DoubleValue` Well-Known-Type.\n *\n * @generated from message buf.validate.DoubleRules\n */\nexport type DoubleRules = Message<\"buf.validate.DoubleRules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyDouble {\n * // value must equal 42.0\n * double value = 1 [(buf.validate.field).double.const = 42.0];\n * }\n * ```\n *\n * @generated from field: optional double const = 1;\n */\n const: number;\n\n /**\n * @generated from oneof buf.validate.DoubleRules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field <\n * value). If the field value is equal to or greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MyDouble {\n * // value must be less than 10.0\n * double value = 1 [(buf.validate.field).double.lt = 10.0];\n * }\n * ```\n *\n * @generated from field: double lt = 2;\n */\n value: number;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified value\n * (field <= value). If the field value is greater than the specified value,\n * an error message is generated.\n *\n * ```proto\n * message MyDouble {\n * // value must be less than or equal to 10.0\n * double value = 1 [(buf.validate.field).double.lte = 10.0];\n * }\n * ```\n *\n * @generated from field: double lte = 3;\n */\n value: number;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.DoubleRules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or `lte`,\n * the range is reversed, and the field value must be outside the specified\n * range. If the field value doesn't meet the required conditions, an error\n * message is generated.\n *\n * ```proto\n * message MyDouble {\n * // value must be greater than 5.0 [double.gt]\n * double value = 1 [(buf.validate.field).double.gt = 5.0];\n *\n * // value must be greater than 5 and less than 10.0 [double.gt_lt]\n * double other_value = 2 [(buf.validate.field).double = { gt: 5.0, lt: 10.0 }];\n *\n * // value must be greater than 10 or less than 5.0 [double.gt_lt_exclusive]\n * double another_value = 3 [(buf.validate.field).double = { gt: 10.0, lt: 5.0 }];\n * }\n * ```\n *\n * @generated from field: double gt = 4;\n */\n value: number;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyDouble {\n * // value must be greater than or equal to 5.0 [double.gte]\n * double value = 1 [(buf.validate.field).double.gte = 5.0];\n *\n * // value must be greater than or equal to 5.0 and less than 10.0 [double.gte_lt]\n * double other_value = 2 [(buf.validate.field).double = { gte: 5.0, lt: 10.0 }];\n *\n * // value must be greater than or equal to 10.0 or less than 5.0 [double.gte_lt_exclusive]\n * double another_value = 3 [(buf.validate.field).double = { gte: 10.0, lt: 5.0 }];\n * }\n * ```\n *\n * @generated from field: double gte = 5;\n */\n value: number;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MyDouble {\n * // value must be in list [1.0, 2.0, 3.0]\n * repeated double value = 1 (buf.validate.field).double = { in: [1.0, 2.0, 3.0] };\n * }\n * ```\n *\n * @generated from field: repeated double in = 6;\n */\n in: number[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MyDouble {\n * // value must not be in list [1.0, 2.0, 3.0]\n * repeated double value = 1 (buf.validate.field).double = { not_in: [1.0, 2.0, 3.0] };\n * }\n * ```\n *\n * @generated from field: repeated double not_in = 7;\n */\n notIn: number[];\n\n /**\n * `finite` requires the field value to be finite. If the field value is\n * infinite or NaN, an error message is generated.\n *\n * @generated from field: optional bool finite = 8;\n */\n finite: boolean;\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyDouble {\n * double value = 1 [\n * (buf.validate.field).double.example = 1.0,\n * (buf.validate.field).double.example = \"Infinity\"\n * ];\n * }\n * ```\n *\n * @generated from field: repeated double example = 9;\n */\n example: number[];\n};\n\n/**\n * Describes the message buf.validate.DoubleRules.\n * Use `create(DoubleRulesSchema)` to create a new message.\n */\nexport const DoubleRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 6);\n\n/**\n * Int32Rules describes the constraints applied to `int32` values. These\n * rules may also be applied to the `google.protobuf.Int32Value` Well-Known-Type.\n *\n * @generated from message buf.validate.Int32Rules\n */\nexport type Int32Rules = Message<\"buf.validate.Int32Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyInt32 {\n * // value must equal 42\n * int32 value = 1 [(buf.validate.field).int32.const = 42];\n * }\n * ```\n *\n * @generated from field: optional int32 const = 1;\n */\n const: number;\n\n /**\n * @generated from oneof buf.validate.Int32Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field\n * < value). If the field value is equal to or greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MyInt32 {\n * // value must be less than 10\n * int32 value = 1 [(buf.validate.field).int32.lt = 10];\n * }\n * ```\n *\n * @generated from field: int32 lt = 2;\n */\n value: number;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MyInt32 {\n * // value must be less than or equal to 10\n * int32 value = 1 [(buf.validate.field).int32.lte = 10];\n * }\n * ```\n *\n * @generated from field: int32 lte = 3;\n */\n value: number;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.Int32Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyInt32 {\n * // value must be greater than 5 [int32.gt]\n * int32 value = 1 [(buf.validate.field).int32.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [int32.gt_lt]\n * int32 other_value = 2 [(buf.validate.field).int32 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [int32.gt_lt_exclusive]\n * int32 another_value = 3 [(buf.validate.field).int32 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: int32 gt = 4;\n */\n value: number;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified value\n * (exclusive). If the value of `gte` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyInt32 {\n * // value must be greater than or equal to 5 [int32.gte]\n * int32 value = 1 [(buf.validate.field).int32.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [int32.gte_lt]\n * int32 other_value = 2 [(buf.validate.field).int32 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [int32.gte_lt_exclusive]\n * int32 another_value = 3 [(buf.validate.field).int32 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: int32 gte = 5;\n */\n value: number;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MyInt32 {\n * // value must be in list [1, 2, 3]\n * repeated int32 value = 1 (buf.validate.field).int32 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated int32 in = 6;\n */\n in: number[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error message\n * is generated.\n *\n * ```proto\n * message MyInt32 {\n * // value must not be in list [1, 2, 3]\n * repeated int32 value = 1 (buf.validate.field).int32 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated int32 not_in = 7;\n */\n notIn: number[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyInt32 {\n * int32 value = 1 [\n * (buf.validate.field).int32.example = 1,\n * (buf.validate.field).int32.example = -10\n * ];\n * }\n * ```\n *\n * @generated from field: repeated int32 example = 8;\n */\n example: number[];\n};\n\n/**\n * Describes the message buf.validate.Int32Rules.\n * Use `create(Int32RulesSchema)` to create a new message.\n */\nexport const Int32RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 7);\n\n/**\n * Int64Rules describes the constraints applied to `int64` values. These\n * rules may also be applied to the `google.protobuf.Int64Value` Well-Known-Type.\n *\n * @generated from message buf.validate.Int64Rules\n */\nexport type Int64Rules = Message<\"buf.validate.Int64Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyInt64 {\n * // value must equal 42\n * int64 value = 1 [(buf.validate.field).int64.const = 42];\n * }\n * ```\n *\n * @generated from field: optional int64 const = 1;\n */\n const: bigint;\n\n /**\n * @generated from oneof buf.validate.Int64Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field <\n * value). If the field value is equal to or greater than the specified value,\n * an error message is generated.\n *\n * ```proto\n * message MyInt64 {\n * // value must be less than 10\n * int64 value = 1 [(buf.validate.field).int64.lt = 10];\n * }\n * ```\n *\n * @generated from field: int64 lt = 2;\n */\n value: bigint;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MyInt64 {\n * // value must be less than or equal to 10\n * int64 value = 1 [(buf.validate.field).int64.lte = 10];\n * }\n * ```\n *\n * @generated from field: int64 lte = 3;\n */\n value: bigint;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.Int64Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyInt64 {\n * // value must be greater than 5 [int64.gt]\n * int64 value = 1 [(buf.validate.field).int64.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [int64.gt_lt]\n * int64 other_value = 2 [(buf.validate.field).int64 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [int64.gt_lt_exclusive]\n * int64 another_value = 3 [(buf.validate.field).int64 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: int64 gt = 4;\n */\n value: bigint;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyInt64 {\n * // value must be greater than or equal to 5 [int64.gte]\n * int64 value = 1 [(buf.validate.field).int64.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [int64.gte_lt]\n * int64 other_value = 2 [(buf.validate.field).int64 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [int64.gte_lt_exclusive]\n * int64 another_value = 3 [(buf.validate.field).int64 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: int64 gte = 5;\n */\n value: bigint;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MyInt64 {\n * // value must be in list [1, 2, 3]\n * repeated int64 value = 1 (buf.validate.field).int64 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated int64 in = 6;\n */\n in: bigint[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MyInt64 {\n * // value must not be in list [1, 2, 3]\n * repeated int64 value = 1 (buf.validate.field).int64 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated int64 not_in = 7;\n */\n notIn: bigint[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyInt64 {\n * int64 value = 1 [\n * (buf.validate.field).int64.example = 1,\n * (buf.validate.field).int64.example = -10\n * ];\n * }\n * ```\n *\n * @generated from field: repeated int64 example = 9;\n */\n example: bigint[];\n};\n\n/**\n * Describes the message buf.validate.Int64Rules.\n * Use `create(Int64RulesSchema)` to create a new message.\n */\nexport const Int64RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 8);\n\n/**\n * UInt32Rules describes the constraints applied to `uint32` values. These\n * rules may also be applied to the `google.protobuf.UInt32Value` Well-Known-Type.\n *\n * @generated from message buf.validate.UInt32Rules\n */\nexport type UInt32Rules = Message<\"buf.validate.UInt32Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyUInt32 {\n * // value must equal 42\n * uint32 value = 1 [(buf.validate.field).uint32.const = 42];\n * }\n * ```\n *\n * @generated from field: optional uint32 const = 1;\n */\n const: number;\n\n /**\n * @generated from oneof buf.validate.UInt32Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field <\n * value). If the field value is equal to or greater than the specified value,\n * an error message is generated.\n *\n * ```proto\n * message MyUInt32 {\n * // value must be less than 10\n * uint32 value = 1 [(buf.validate.field).uint32.lt = 10];\n * }\n * ```\n *\n * @generated from field: uint32 lt = 2;\n */\n value: number;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MyUInt32 {\n * // value must be less than or equal to 10\n * uint32 value = 1 [(buf.validate.field).uint32.lte = 10];\n * }\n * ```\n *\n * @generated from field: uint32 lte = 3;\n */\n value: number;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.UInt32Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyUInt32 {\n * // value must be greater than 5 [uint32.gt]\n * uint32 value = 1 [(buf.validate.field).uint32.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [uint32.gt_lt]\n * uint32 other_value = 2 [(buf.validate.field).uint32 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [uint32.gt_lt_exclusive]\n * uint32 another_value = 3 [(buf.validate.field).uint32 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: uint32 gt = 4;\n */\n value: number;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyUInt32 {\n * // value must be greater than or equal to 5 [uint32.gte]\n * uint32 value = 1 [(buf.validate.field).uint32.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [uint32.gte_lt]\n * uint32 other_value = 2 [(buf.validate.field).uint32 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [uint32.gte_lt_exclusive]\n * uint32 another_value = 3 [(buf.validate.field).uint32 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: uint32 gte = 5;\n */\n value: number;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MyUInt32 {\n * // value must be in list [1, 2, 3]\n * repeated uint32 value = 1 (buf.validate.field).uint32 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated uint32 in = 6;\n */\n in: number[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MyUInt32 {\n * // value must not be in list [1, 2, 3]\n * repeated uint32 value = 1 (buf.validate.field).uint32 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated uint32 not_in = 7;\n */\n notIn: number[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyUInt32 {\n * uint32 value = 1 [\n * (buf.validate.field).uint32.example = 1,\n * (buf.validate.field).uint32.example = 10\n * ];\n * }\n * ```\n *\n * @generated from field: repeated uint32 example = 8;\n */\n example: number[];\n};\n\n/**\n * Describes the message buf.validate.UInt32Rules.\n * Use `create(UInt32RulesSchema)` to create a new message.\n */\nexport const UInt32RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 9);\n\n/**\n * UInt64Rules describes the constraints applied to `uint64` values. These\n * rules may also be applied to the `google.protobuf.UInt64Value` Well-Known-Type.\n *\n * @generated from message buf.validate.UInt64Rules\n */\nexport type UInt64Rules = Message<\"buf.validate.UInt64Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyUInt64 {\n * // value must equal 42\n * uint64 value = 1 [(buf.validate.field).uint64.const = 42];\n * }\n * ```\n *\n * @generated from field: optional uint64 const = 1;\n */\n const: bigint;\n\n /**\n * @generated from oneof buf.validate.UInt64Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field <\n * value). If the field value is equal to or greater than the specified value,\n * an error message is generated.\n *\n * ```proto\n * message MyUInt64 {\n * // value must be less than 10\n * uint64 value = 1 [(buf.validate.field).uint64.lt = 10];\n * }\n * ```\n *\n * @generated from field: uint64 lt = 2;\n */\n value: bigint;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MyUInt64 {\n * // value must be less than or equal to 10\n * uint64 value = 1 [(buf.validate.field).uint64.lte = 10];\n * }\n * ```\n *\n * @generated from field: uint64 lte = 3;\n */\n value: bigint;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.UInt64Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyUInt64 {\n * // value must be greater than 5 [uint64.gt]\n * uint64 value = 1 [(buf.validate.field).uint64.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [uint64.gt_lt]\n * uint64 other_value = 2 [(buf.validate.field).uint64 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [uint64.gt_lt_exclusive]\n * uint64 another_value = 3 [(buf.validate.field).uint64 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: uint64 gt = 4;\n */\n value: bigint;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyUInt64 {\n * // value must be greater than or equal to 5 [uint64.gte]\n * uint64 value = 1 [(buf.validate.field).uint64.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [uint64.gte_lt]\n * uint64 other_value = 2 [(buf.validate.field).uint64 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [uint64.gte_lt_exclusive]\n * uint64 another_value = 3 [(buf.validate.field).uint64 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: uint64 gte = 5;\n */\n value: bigint;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MyUInt64 {\n * // value must be in list [1, 2, 3]\n * repeated uint64 value = 1 (buf.validate.field).uint64 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated uint64 in = 6;\n */\n in: bigint[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MyUInt64 {\n * // value must not be in list [1, 2, 3]\n * repeated uint64 value = 1 (buf.validate.field).uint64 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated uint64 not_in = 7;\n */\n notIn: bigint[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyUInt64 {\n * uint64 value = 1 [\n * (buf.validate.field).uint64.example = 1,\n * (buf.validate.field).uint64.example = -10\n * ];\n * }\n * ```\n *\n * @generated from field: repeated uint64 example = 8;\n */\n example: bigint[];\n};\n\n/**\n * Describes the message buf.validate.UInt64Rules.\n * Use `create(UInt64RulesSchema)` to create a new message.\n */\nexport const UInt64RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 10);\n\n/**\n * SInt32Rules describes the constraints applied to `sint32` values.\n *\n * @generated from message buf.validate.SInt32Rules\n */\nexport type SInt32Rules = Message<\"buf.validate.SInt32Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MySInt32 {\n * // value must equal 42\n * sint32 value = 1 [(buf.validate.field).sint32.const = 42];\n * }\n * ```\n *\n * @generated from field: optional sint32 const = 1;\n */\n const: number;\n\n /**\n * @generated from oneof buf.validate.SInt32Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field\n * < value). If the field value is equal to or greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MySInt32 {\n * // value must be less than 10\n * sint32 value = 1 [(buf.validate.field).sint32.lt = 10];\n * }\n * ```\n *\n * @generated from field: sint32 lt = 2;\n */\n value: number;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MySInt32 {\n * // value must be less than or equal to 10\n * sint32 value = 1 [(buf.validate.field).sint32.lte = 10];\n * }\n * ```\n *\n * @generated from field: sint32 lte = 3;\n */\n value: number;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.SInt32Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MySInt32 {\n * // value must be greater than 5 [sint32.gt]\n * sint32 value = 1 [(buf.validate.field).sint32.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [sint32.gt_lt]\n * sint32 other_value = 2 [(buf.validate.field).sint32 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [sint32.gt_lt_exclusive]\n * sint32 another_value = 3 [(buf.validate.field).sint32 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: sint32 gt = 4;\n */\n value: number;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MySInt32 {\n * // value must be greater than or equal to 5 [sint32.gte]\n * sint32 value = 1 [(buf.validate.field).sint32.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [sint32.gte_lt]\n * sint32 other_value = 2 [(buf.validate.field).sint32 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [sint32.gte_lt_exclusive]\n * sint32 another_value = 3 [(buf.validate.field).sint32 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: sint32 gte = 5;\n */\n value: number;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MySInt32 {\n * // value must be in list [1, 2, 3]\n * repeated sint32 value = 1 (buf.validate.field).sint32 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated sint32 in = 6;\n */\n in: number[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MySInt32 {\n * // value must not be in list [1, 2, 3]\n * repeated sint32 value = 1 (buf.validate.field).sint32 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated sint32 not_in = 7;\n */\n notIn: number[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MySInt32 {\n * sint32 value = 1 [\n * (buf.validate.field).sint32.example = 1,\n * (buf.validate.field).sint32.example = -10\n * ];\n * }\n * ```\n *\n * @generated from field: repeated sint32 example = 8;\n */\n example: number[];\n};\n\n/**\n * Describes the message buf.validate.SInt32Rules.\n * Use `create(SInt32RulesSchema)` to create a new message.\n */\nexport const SInt32RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 11);\n\n/**\n * SInt64Rules describes the constraints applied to `sint64` values.\n *\n * @generated from message buf.validate.SInt64Rules\n */\nexport type SInt64Rules = Message<\"buf.validate.SInt64Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MySInt64 {\n * // value must equal 42\n * sint64 value = 1 [(buf.validate.field).sint64.const = 42];\n * }\n * ```\n *\n * @generated from field: optional sint64 const = 1;\n */\n const: bigint;\n\n /**\n * @generated from oneof buf.validate.SInt64Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field\n * < value). If the field value is equal to or greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MySInt64 {\n * // value must be less than 10\n * sint64 value = 1 [(buf.validate.field).sint64.lt = 10];\n * }\n * ```\n *\n * @generated from field: sint64 lt = 2;\n */\n value: bigint;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MySInt64 {\n * // value must be less than or equal to 10\n * sint64 value = 1 [(buf.validate.field).sint64.lte = 10];\n * }\n * ```\n *\n * @generated from field: sint64 lte = 3;\n */\n value: bigint;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.SInt64Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MySInt64 {\n * // value must be greater than 5 [sint64.gt]\n * sint64 value = 1 [(buf.validate.field).sint64.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [sint64.gt_lt]\n * sint64 other_value = 2 [(buf.validate.field).sint64 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [sint64.gt_lt_exclusive]\n * sint64 another_value = 3 [(buf.validate.field).sint64 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: sint64 gt = 4;\n */\n value: bigint;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MySInt64 {\n * // value must be greater than or equal to 5 [sint64.gte]\n * sint64 value = 1 [(buf.validate.field).sint64.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [sint64.gte_lt]\n * sint64 other_value = 2 [(buf.validate.field).sint64 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [sint64.gte_lt_exclusive]\n * sint64 another_value = 3 [(buf.validate.field).sint64 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: sint64 gte = 5;\n */\n value: bigint;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message\n * is generated.\n *\n * ```proto\n * message MySInt64 {\n * // value must be in list [1, 2, 3]\n * repeated sint64 value = 1 (buf.validate.field).sint64 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated sint64 in = 6;\n */\n in: bigint[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MySInt64 {\n * // value must not be in list [1, 2, 3]\n * repeated sint64 value = 1 (buf.validate.field).sint64 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated sint64 not_in = 7;\n */\n notIn: bigint[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MySInt64 {\n * sint64 value = 1 [\n * (buf.validate.field).sint64.example = 1,\n * (buf.validate.field).sint64.example = -10\n * ];\n * }\n * ```\n *\n * @generated from field: repeated sint64 example = 8;\n */\n example: bigint[];\n};\n\n/**\n * Describes the message buf.validate.SInt64Rules.\n * Use `create(SInt64RulesSchema)` to create a new message.\n */\nexport const SInt64RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 12);\n\n/**\n * Fixed32Rules describes the constraints applied to `fixed32` values.\n *\n * @generated from message buf.validate.Fixed32Rules\n */\nexport type Fixed32Rules = Message<\"buf.validate.Fixed32Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value.\n * If the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyFixed32 {\n * // value must equal 42\n * fixed32 value = 1 [(buf.validate.field).fixed32.const = 42];\n * }\n * ```\n *\n * @generated from field: optional fixed32 const = 1;\n */\n const: number;\n\n /**\n * @generated from oneof buf.validate.Fixed32Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field <\n * value). If the field value is equal to or greater than the specified value,\n * an error message is generated.\n *\n * ```proto\n * message MyFixed32 {\n * // value must be less than 10\n * fixed32 value = 1 [(buf.validate.field).fixed32.lt = 10];\n * }\n * ```\n *\n * @generated from field: fixed32 lt = 2;\n */\n value: number;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MyFixed32 {\n * // value must be less than or equal to 10\n * fixed32 value = 1 [(buf.validate.field).fixed32.lte = 10];\n * }\n * ```\n *\n * @generated from field: fixed32 lte = 3;\n */\n value: number;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.Fixed32Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyFixed32 {\n * // value must be greater than 5 [fixed32.gt]\n * fixed32 value = 1 [(buf.validate.field).fixed32.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [fixed32.gt_lt]\n * fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [fixed32.gt_lt_exclusive]\n * fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: fixed32 gt = 4;\n */\n value: number;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyFixed32 {\n * // value must be greater than or equal to 5 [fixed32.gte]\n * fixed32 value = 1 [(buf.validate.field).fixed32.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [fixed32.gte_lt]\n * fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [fixed32.gte_lt_exclusive]\n * fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: fixed32 gte = 5;\n */\n value: number;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message\n * is generated.\n *\n * ```proto\n * message MyFixed32 {\n * // value must be in list [1, 2, 3]\n * repeated fixed32 value = 1 (buf.validate.field).fixed32 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated fixed32 in = 6;\n */\n in: number[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MyFixed32 {\n * // value must not be in list [1, 2, 3]\n * repeated fixed32 value = 1 (buf.validate.field).fixed32 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated fixed32 not_in = 7;\n */\n notIn: number[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyFixed32 {\n * fixed32 value = 1 [\n * (buf.validate.field).fixed32.example = 1,\n * (buf.validate.field).fixed32.example = 2\n * ];\n * }\n * ```\n *\n * @generated from field: repeated fixed32 example = 8;\n */\n example: number[];\n};\n\n/**\n * Describes the message buf.validate.Fixed32Rules.\n * Use `create(Fixed32RulesSchema)` to create a new message.\n */\nexport const Fixed32RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 13);\n\n/**\n * Fixed64Rules describes the constraints applied to `fixed64` values.\n *\n * @generated from message buf.validate.Fixed64Rules\n */\nexport type Fixed64Rules = Message<\"buf.validate.Fixed64Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyFixed64 {\n * // value must equal 42\n * fixed64 value = 1 [(buf.validate.field).fixed64.const = 42];\n * }\n * ```\n *\n * @generated from field: optional fixed64 const = 1;\n */\n const: bigint;\n\n /**\n * @generated from oneof buf.validate.Fixed64Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field <\n * value). If the field value is equal to or greater than the specified value,\n * an error message is generated.\n *\n * ```proto\n * message MyFixed64 {\n * // value must be less than 10\n * fixed64 value = 1 [(buf.validate.field).fixed64.lt = 10];\n * }\n * ```\n *\n * @generated from field: fixed64 lt = 2;\n */\n value: bigint;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MyFixed64 {\n * // value must be less than or equal to 10\n * fixed64 value = 1 [(buf.validate.field).fixed64.lte = 10];\n * }\n * ```\n *\n * @generated from field: fixed64 lte = 3;\n */\n value: bigint;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.Fixed64Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyFixed64 {\n * // value must be greater than 5 [fixed64.gt]\n * fixed64 value = 1 [(buf.validate.field).fixed64.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [fixed64.gt_lt]\n * fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [fixed64.gt_lt_exclusive]\n * fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: fixed64 gt = 4;\n */\n value: bigint;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyFixed64 {\n * // value must be greater than or equal to 5 [fixed64.gte]\n * fixed64 value = 1 [(buf.validate.field).fixed64.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [fixed64.gte_lt]\n * fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [fixed64.gte_lt_exclusive]\n * fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: fixed64 gte = 5;\n */\n value: bigint;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MyFixed64 {\n * // value must be in list [1, 2, 3]\n * repeated fixed64 value = 1 (buf.validate.field).fixed64 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated fixed64 in = 6;\n */\n in: bigint[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MyFixed64 {\n * // value must not be in list [1, 2, 3]\n * repeated fixed64 value = 1 (buf.validate.field).fixed64 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated fixed64 not_in = 7;\n */\n notIn: bigint[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyFixed64 {\n * fixed64 value = 1 [\n * (buf.validate.field).fixed64.example = 1,\n * (buf.validate.field).fixed64.example = 2\n * ];\n * }\n * ```\n *\n * @generated from field: repeated fixed64 example = 8;\n */\n example: bigint[];\n};\n\n/**\n * Describes the message buf.validate.Fixed64Rules.\n * Use `create(Fixed64RulesSchema)` to create a new message.\n */\nexport const Fixed64RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 14);\n\n/**\n * SFixed32Rules describes the constraints applied to `fixed32` values.\n *\n * @generated from message buf.validate.SFixed32Rules\n */\nexport type SFixed32Rules = Message<\"buf.validate.SFixed32Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MySFixed32 {\n * // value must equal 42\n * sfixed32 value = 1 [(buf.validate.field).sfixed32.const = 42];\n * }\n * ```\n *\n * @generated from field: optional sfixed32 const = 1;\n */\n const: number;\n\n /**\n * @generated from oneof buf.validate.SFixed32Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field <\n * value). If the field value is equal to or greater than the specified value,\n * an error message is generated.\n *\n * ```proto\n * message MySFixed32 {\n * // value must be less than 10\n * sfixed32 value = 1 [(buf.validate.field).sfixed32.lt = 10];\n * }\n * ```\n *\n * @generated from field: sfixed32 lt = 2;\n */\n value: number;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MySFixed32 {\n * // value must be less than or equal to 10\n * sfixed32 value = 1 [(buf.validate.field).sfixed32.lte = 10];\n * }\n * ```\n *\n * @generated from field: sfixed32 lte = 3;\n */\n value: number;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.SFixed32Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MySFixed32 {\n * // value must be greater than 5 [sfixed32.gt]\n * sfixed32 value = 1 [(buf.validate.field).sfixed32.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [sfixed32.gt_lt]\n * sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [sfixed32.gt_lt_exclusive]\n * sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: sfixed32 gt = 4;\n */\n value: number;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MySFixed32 {\n * // value must be greater than or equal to 5 [sfixed32.gte]\n * sfixed32 value = 1 [(buf.validate.field).sfixed32.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [sfixed32.gte_lt]\n * sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [sfixed32.gte_lt_exclusive]\n * sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: sfixed32 gte = 5;\n */\n value: number;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MySFixed32 {\n * // value must be in list [1, 2, 3]\n * repeated sfixed32 value = 1 (buf.validate.field).sfixed32 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated sfixed32 in = 6;\n */\n in: number[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MySFixed32 {\n * // value must not be in list [1, 2, 3]\n * repeated sfixed32 value = 1 (buf.validate.field).sfixed32 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated sfixed32 not_in = 7;\n */\n notIn: number[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MySFixed32 {\n * sfixed32 value = 1 [\n * (buf.validate.field).sfixed32.example = 1,\n * (buf.validate.field).sfixed32.example = 2\n * ];\n * }\n * ```\n *\n * @generated from field: repeated sfixed32 example = 8;\n */\n example: number[];\n};\n\n/**\n * Describes the message buf.validate.SFixed32Rules.\n * Use `create(SFixed32RulesSchema)` to create a new message.\n */\nexport const SFixed32RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 15);\n\n/**\n * SFixed64Rules describes the constraints applied to `fixed64` values.\n *\n * @generated from message buf.validate.SFixed64Rules\n */\nexport type SFixed64Rules = Message<\"buf.validate.SFixed64Rules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MySFixed64 {\n * // value must equal 42\n * sfixed64 value = 1 [(buf.validate.field).sfixed64.const = 42];\n * }\n * ```\n *\n * @generated from field: optional sfixed64 const = 1;\n */\n const: bigint;\n\n /**\n * @generated from oneof buf.validate.SFixed64Rules.less_than\n */\n lessThan: {\n /**\n * `lt` requires the field value to be less than the specified value (field <\n * value). If the field value is equal to or greater than the specified value,\n * an error message is generated.\n *\n * ```proto\n * message MySFixed64 {\n * // value must be less than 10\n * sfixed64 value = 1 [(buf.validate.field).sfixed64.lt = 10];\n * }\n * ```\n *\n * @generated from field: sfixed64 lt = 2;\n */\n value: bigint;\n case: \"lt\";\n } | {\n /**\n * `lte` requires the field value to be less than or equal to the specified\n * value (field <= value). If the field value is greater than the specified\n * value, an error message is generated.\n *\n * ```proto\n * message MySFixed64 {\n * // value must be less than or equal to 10\n * sfixed64 value = 1 [(buf.validate.field).sfixed64.lte = 10];\n * }\n * ```\n *\n * @generated from field: sfixed64 lte = 3;\n */\n value: bigint;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.SFixed64Rules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the field value to be greater than the specified value\n * (exclusive). If the value of `gt` is larger than a specified `lt` or\n * `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MySFixed64 {\n * // value must be greater than 5 [sfixed64.gt]\n * sfixed64 value = 1 [(buf.validate.field).sfixed64.gt = 5];\n *\n * // value must be greater than 5 and less than 10 [sfixed64.gt_lt]\n * sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gt: 5, lt: 10 }];\n *\n * // value must be greater than 10 or less than 5 [sfixed64.gt_lt_exclusive]\n * sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gt: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: sfixed64 gt = 4;\n */\n value: bigint;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the field value to be greater than or equal to the specified\n * value (exclusive). If the value of `gte` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MySFixed64 {\n * // value must be greater than or equal to 5 [sfixed64.gte]\n * sfixed64 value = 1 [(buf.validate.field).sfixed64.gte = 5];\n *\n * // value must be greater than or equal to 5 and less than 10 [sfixed64.gte_lt]\n * sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gte: 5, lt: 10 }];\n *\n * // value must be greater than or equal to 10 or less than 5 [sfixed64.gte_lt_exclusive]\n * sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gte: 10, lt: 5 }];\n * }\n * ```\n *\n * @generated from field: sfixed64 gte = 5;\n */\n value: bigint;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` requires the field value to be equal to one of the specified values.\n * If the field value isn't one of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MySFixed64 {\n * // value must be in list [1, 2, 3]\n * repeated sfixed64 value = 1 (buf.validate.field).sfixed64 = { in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated sfixed64 in = 6;\n */\n in: bigint[];\n\n /**\n * `not_in` requires the field value to not be equal to any of the specified\n * values. If the field value is one of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MySFixed64 {\n * // value must not be in list [1, 2, 3]\n * repeated sfixed64 value = 1 (buf.validate.field).sfixed64 = { not_in: [1, 2, 3] };\n * }\n * ```\n *\n * @generated from field: repeated sfixed64 not_in = 7;\n */\n notIn: bigint[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MySFixed64 {\n * sfixed64 value = 1 [\n * (buf.validate.field).sfixed64.example = 1,\n * (buf.validate.field).sfixed64.example = 2\n * ];\n * }\n * ```\n *\n * @generated from field: repeated sfixed64 example = 8;\n */\n example: bigint[];\n};\n\n/**\n * Describes the message buf.validate.SFixed64Rules.\n * Use `create(SFixed64RulesSchema)` to create a new message.\n */\nexport const SFixed64RulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 16);\n\n/**\n * BoolRules describes the constraints applied to `bool` values. These rules\n * may also be applied to the `google.protobuf.BoolValue` Well-Known-Type.\n *\n * @generated from message buf.validate.BoolRules\n */\nexport type BoolRules = Message<\"buf.validate.BoolRules\"> & {\n /**\n * `const` requires the field value to exactly match the specified boolean value.\n * If the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyBool {\n * // value must equal true\n * bool value = 1 [(buf.validate.field).bool.const = true];\n * }\n * ```\n *\n * @generated from field: optional bool const = 1;\n */\n const: boolean;\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyBool {\n * bool value = 1 [\n * (buf.validate.field).bool.example = 1,\n * (buf.validate.field).bool.example = 2\n * ];\n * }\n * ```\n *\n * @generated from field: repeated bool example = 2;\n */\n example: boolean[];\n};\n\n/**\n * Describes the message buf.validate.BoolRules.\n * Use `create(BoolRulesSchema)` to create a new message.\n */\nexport const BoolRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 17);\n\n/**\n * StringRules describes the constraints applied to `string` values These\n * rules may also be applied to the `google.protobuf.StringValue` Well-Known-Type.\n *\n * @generated from message buf.validate.StringRules\n */\nexport type StringRules = Message<\"buf.validate.StringRules\"> & {\n /**\n * `const` requires the field value to exactly match the specified value. If\n * the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyString {\n * // value must equal `hello`\n * string value = 1 [(buf.validate.field).string.const = \"hello\"];\n * }\n * ```\n *\n * @generated from field: optional string const = 1;\n */\n const: string;\n\n /**\n * `len` dictates that the field value must have the specified\n * number of characters (Unicode code points), which may differ from the number\n * of bytes in the string. If the field value does not meet the specified\n * length, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value length must be 5 characters\n * string value = 1 [(buf.validate.field).string.len = 5];\n * }\n * ```\n *\n * @generated from field: optional uint64 len = 19;\n */\n len: bigint;\n\n /**\n * `min_len` specifies that the field value must have at least the specified\n * number of characters (Unicode code points), which may differ from the number\n * of bytes in the string. If the field value contains fewer characters, an error\n * message will be generated.\n *\n * ```proto\n * message MyString {\n * // value length must be at least 3 characters\n * string value = 1 [(buf.validate.field).string.min_len = 3];\n * }\n * ```\n *\n * @generated from field: optional uint64 min_len = 2;\n */\n minLen: bigint;\n\n /**\n * `max_len` specifies that the field value must have no more than the specified\n * number of characters (Unicode code points), which may differ from the\n * number of bytes in the string. If the field value contains more characters,\n * an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value length must be at most 10 characters\n * string value = 1 [(buf.validate.field).string.max_len = 10];\n * }\n * ```\n *\n * @generated from field: optional uint64 max_len = 3;\n */\n maxLen: bigint;\n\n /**\n * `len_bytes` dictates that the field value must have the specified number of\n * bytes. If the field value does not match the specified length in bytes,\n * an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value length must be 6 bytes\n * string value = 1 [(buf.validate.field).string.len_bytes = 6];\n * }\n * ```\n *\n * @generated from field: optional uint64 len_bytes = 20;\n */\n lenBytes: bigint;\n\n /**\n * `min_bytes` specifies that the field value must have at least the specified\n * number of bytes. If the field value contains fewer bytes, an error message\n * will be generated.\n *\n * ```proto\n * message MyString {\n * // value length must be at least 4 bytes\n * string value = 1 [(buf.validate.field).string.min_bytes = 4];\n * }\n *\n * ```\n *\n * @generated from field: optional uint64 min_bytes = 4;\n */\n minBytes: bigint;\n\n /**\n * `max_bytes` specifies that the field value must have no more than the\n * specified number of bytes. If the field value contains more bytes, an\n * error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value length must be at most 8 bytes\n * string value = 1 [(buf.validate.field).string.max_bytes = 8];\n * }\n * ```\n *\n * @generated from field: optional uint64 max_bytes = 5;\n */\n maxBytes: bigint;\n\n /**\n * `pattern` specifies that the field value must match the specified\n * regular expression (RE2 syntax), with the expression provided without any\n * delimiters. If the field value doesn't match the regular expression, an\n * error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value does not match regex pattern `^[a-zA-Z]//$`\n * string value = 1 [(buf.validate.field).string.pattern = \"^[a-zA-Z]//$\"];\n * }\n * ```\n *\n * @generated from field: optional string pattern = 6;\n */\n pattern: string;\n\n /**\n * `prefix` specifies that the field value must have the\n * specified substring at the beginning of the string. If the field value\n * doesn't start with the specified prefix, an error message will be\n * generated.\n *\n * ```proto\n * message MyString {\n * // value does not have prefix `pre`\n * string value = 1 [(buf.validate.field).string.prefix = \"pre\"];\n * }\n * ```\n *\n * @generated from field: optional string prefix = 7;\n */\n prefix: string;\n\n /**\n * `suffix` specifies that the field value must have the\n * specified substring at the end of the string. If the field value doesn't\n * end with the specified suffix, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value does not have suffix `post`\n * string value = 1 [(buf.validate.field).string.suffix = \"post\"];\n * }\n * ```\n *\n * @generated from field: optional string suffix = 8;\n */\n suffix: string;\n\n /**\n * `contains` specifies that the field value must have the\n * specified substring anywhere in the string. If the field value doesn't\n * contain the specified substring, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value does not contain substring `inside`.\n * string value = 1 [(buf.validate.field).string.contains = \"inside\"];\n * }\n * ```\n *\n * @generated from field: optional string contains = 9;\n */\n contains: string;\n\n /**\n * `not_contains` specifies that the field value must not have the\n * specified substring anywhere in the string. If the field value contains\n * the specified substring, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value contains substring `inside`.\n * string value = 1 [(buf.validate.field).string.not_contains = \"inside\"];\n * }\n * ```\n *\n * @generated from field: optional string not_contains = 23;\n */\n notContains: string;\n\n /**\n * `in` specifies that the field value must be equal to one of the specified\n * values. If the field value isn't one of the specified values, an error\n * message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be in list [\"apple\", \"banana\"]\n * repeated string value = 1 [(buf.validate.field).string.in = \"apple\", (buf.validate.field).string.in = \"banana\"];\n * }\n * ```\n *\n * @generated from field: repeated string in = 10;\n */\n in: string[];\n\n /**\n * `not_in` specifies that the field value cannot be equal to any\n * of the specified values. If the field value is one of the specified values,\n * an error message will be generated.\n * ```proto\n * message MyString {\n * // value must not be in list [\"orange\", \"grape\"]\n * repeated string value = 1 [(buf.validate.field).string.not_in = \"orange\", (buf.validate.field).string.not_in = \"grape\"];\n * }\n * ```\n *\n * @generated from field: repeated string not_in = 11;\n */\n notIn: string[];\n\n /**\n * `WellKnown` rules provide advanced constraints against common string\n * patterns\n *\n * @generated from oneof buf.validate.StringRules.well_known\n */\n wellKnown: {\n /**\n * `email` specifies that the field value must be a valid email address\n * (addr-spec only) as defined by [RFC 5322](https://tools.ietf.org/html/rfc5322#section-3.4.1).\n * If the field value isn't a valid email address, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid email address\n * string value = 1 [(buf.validate.field).string.email = true];\n * }\n * ```\n *\n * @generated from field: bool email = 12;\n */\n value: boolean;\n case: \"email\";\n } | {\n /**\n * `hostname` specifies that the field value must be a valid\n * hostname as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5). This constraint doesn't support\n * internationalized domain names (IDNs). If the field value isn't a\n * valid hostname, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid hostname\n * string value = 1 [(buf.validate.field).string.hostname = true];\n * }\n * ```\n *\n * @generated from field: bool hostname = 13;\n */\n value: boolean;\n case: \"hostname\";\n } | {\n /**\n * `ip` specifies that the field value must be a valid IP\n * (v4 or v6) address, without surrounding square brackets for IPv6 addresses.\n * If the field value isn't a valid IP address, an error message will be\n * generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid IP address\n * string value = 1 [(buf.validate.field).string.ip = true];\n * }\n * ```\n *\n * @generated from field: bool ip = 14;\n */\n value: boolean;\n case: \"ip\";\n } | {\n /**\n * `ipv4` specifies that the field value must be a valid IPv4\n * address. If the field value isn't a valid IPv4 address, an error message\n * will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid IPv4 address\n * string value = 1 [(buf.validate.field).string.ipv4 = true];\n * }\n * ```\n *\n * @generated from field: bool ipv4 = 15;\n */\n value: boolean;\n case: \"ipv4\";\n } | {\n /**\n * `ipv6` specifies that the field value must be a valid\n * IPv6 address, without surrounding square brackets. If the field value is\n * not a valid IPv6 address, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid IPv6 address\n * string value = 1 [(buf.validate.field).string.ipv6 = true];\n * }\n * ```\n *\n * @generated from field: bool ipv6 = 16;\n */\n value: boolean;\n case: \"ipv6\";\n } | {\n /**\n * `uri` specifies that the field value must be a valid,\n * absolute URI as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3). If the field value isn't a valid,\n * absolute URI, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid URI\n * string value = 1 [(buf.validate.field).string.uri = true];\n * }\n * ```\n *\n * @generated from field: bool uri = 17;\n */\n value: boolean;\n case: \"uri\";\n } | {\n /**\n * `uri_ref` specifies that the field value must be a valid URI\n * as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) and may be either relative or absolute. If the\n * field value isn't a valid URI, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid URI\n * string value = 1 [(buf.validate.field).string.uri_ref = true];\n * }\n * ```\n *\n * @generated from field: bool uri_ref = 18;\n */\n value: boolean;\n case: \"uriRef\";\n } | {\n /**\n * `address` specifies that the field value must be either a valid hostname\n * as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5)\n * (which doesn't support internationalized domain names or IDNs) or a valid\n * IP (v4 or v6). If the field value isn't a valid hostname or IP, an error\n * message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid hostname, or ip address\n * string value = 1 [(buf.validate.field).string.address = true];\n * }\n * ```\n *\n * @generated from field: bool address = 21;\n */\n value: boolean;\n case: \"address\";\n } | {\n /**\n * `uuid` specifies that the field value must be a valid UUID as defined by\n * [RFC 4122](https://tools.ietf.org/html/rfc4122#section-4.1.2). If the\n * field value isn't a valid UUID, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid UUID\n * string value = 1 [(buf.validate.field).string.uuid = true];\n * }\n * ```\n *\n * @generated from field: bool uuid = 22;\n */\n value: boolean;\n case: \"uuid\";\n } | {\n /**\n * `tuuid` (trimmed UUID) specifies that the field value must be a valid UUID as\n * defined by [RFC 4122](https://tools.ietf.org/html/rfc4122#section-4.1.2) with all dashes\n * omitted. If the field value isn't a valid UUID without dashes, an error message\n * will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid trimmed UUID\n * string value = 1 [(buf.validate.field).string.tuuid = true];\n * }\n * ```\n *\n * @generated from field: bool tuuid = 33;\n */\n value: boolean;\n case: \"tuuid\";\n } | {\n /**\n * `ip_with_prefixlen` specifies that the field value must be a valid IP (v4 or v6)\n * address with prefix length. If the field value isn't a valid IP with prefix\n * length, an error message will be generated.\n *\n *\n * ```proto\n * message MyString {\n * // value must be a valid IP with prefix length\n * string value = 1 [(buf.validate.field).string.ip_with_prefixlen = true];\n * }\n * ```\n *\n * @generated from field: bool ip_with_prefixlen = 26;\n */\n value: boolean;\n case: \"ipWithPrefixlen\";\n } | {\n /**\n * `ipv4_with_prefixlen` specifies that the field value must be a valid\n * IPv4 address with prefix.\n * If the field value isn't a valid IPv4 address with prefix length,\n * an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid IPv4 address with prefix length\n * string value = 1 [(buf.validate.field).string.ipv4_with_prefixlen = true];\n * }\n * ```\n *\n * @generated from field: bool ipv4_with_prefixlen = 27;\n */\n value: boolean;\n case: \"ipv4WithPrefixlen\";\n } | {\n /**\n * `ipv6_with_prefixlen` specifies that the field value must be a valid\n * IPv6 address with prefix length.\n * If the field value is not a valid IPv6 address with prefix length,\n * an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid IPv6 address prefix length\n * string value = 1 [(buf.validate.field).string.ipv6_with_prefixlen = true];\n * }\n * ```\n *\n * @generated from field: bool ipv6_with_prefixlen = 28;\n */\n value: boolean;\n case: \"ipv6WithPrefixlen\";\n } | {\n /**\n * `ip_prefix` specifies that the field value must be a valid IP (v4 or v6) prefix.\n * If the field value isn't a valid IP prefix, an error message will be\n * generated. The prefix must have all zeros for the masked bits of the prefix (e.g.,\n * `127.0.0.0/16`, not `127.0.0.1/16`).\n *\n * ```proto\n * message MyString {\n * // value must be a valid IP prefix\n * string value = 1 [(buf.validate.field).string.ip_prefix = true];\n * }\n * ```\n *\n * @generated from field: bool ip_prefix = 29;\n */\n value: boolean;\n case: \"ipPrefix\";\n } | {\n /**\n * `ipv4_prefix` specifies that the field value must be a valid IPv4\n * prefix. If the field value isn't a valid IPv4 prefix, an error message\n * will be generated. The prefix must have all zeros for the masked bits of\n * the prefix (e.g., `127.0.0.0/16`, not `127.0.0.1/16`).\n *\n * ```proto\n * message MyString {\n * // value must be a valid IPv4 prefix\n * string value = 1 [(buf.validate.field).string.ipv4_prefix = true];\n * }\n * ```\n *\n * @generated from field: bool ipv4_prefix = 30;\n */\n value: boolean;\n case: \"ipv4Prefix\";\n } | {\n /**\n * `ipv6_prefix` specifies that the field value must be a valid IPv6 prefix.\n * If the field value is not a valid IPv6 prefix, an error message will be\n * generated. The prefix must have all zeros for the masked bits of the prefix\n * (e.g., `2001:db8::/48`, not `2001:db8::1/48`).\n *\n * ```proto\n * message MyString {\n * // value must be a valid IPv6 prefix\n * string value = 1 [(buf.validate.field).string.ipv6_prefix = true];\n * }\n * ```\n *\n * @generated from field: bool ipv6_prefix = 31;\n */\n value: boolean;\n case: \"ipv6Prefix\";\n } | {\n /**\n * `host_and_port` specifies the field value must be a valid host and port\n * pair. The host must be a valid hostname or IP address while the port\n * must be in the range of 0-65535, inclusive. IPv6 addresses must be delimited\n * with square brackets (e.g., `[::1]:1234`).\n *\n * @generated from field: bool host_and_port = 32;\n */\n value: boolean;\n case: \"hostAndPort\";\n } | {\n /**\n * `well_known_regex` specifies a common well-known pattern\n * defined as a regex. If the field value doesn't match the well-known\n * regex, an error message will be generated.\n *\n * ```proto\n * message MyString {\n * // value must be a valid HTTP header value\n * string value = 1 [(buf.validate.field).string.well_known_regex = KNOWN_REGEX_HTTP_HEADER_VALUE];\n * }\n * ```\n *\n * #### KnownRegex\n *\n * `well_known_regex` contains some well-known patterns.\n *\n * | Name | Number | Description |\n * |-------------------------------|--------|-------------------------------------------|\n * | KNOWN_REGEX_UNSPECIFIED | 0 | |\n * | KNOWN_REGEX_HTTP_HEADER_NAME | 1 | HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2) |\n * | KNOWN_REGEX_HTTP_HEADER_VALUE | 2 | HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4) |\n *\n * @generated from field: buf.validate.KnownRegex well_known_regex = 24;\n */\n value: KnownRegex;\n case: \"wellKnownRegex\";\n } | { case: undefined; value?: undefined };\n\n /**\n * This applies to regexes `HTTP_HEADER_NAME` and `HTTP_HEADER_VALUE` to\n * enable strict header validation. By default, this is true, and HTTP header\n * validations are [RFC-compliant](https://tools.ietf.org/html/rfc7230#section-3). Setting to false will enable looser\n * validations that only disallow `\\r\\n\\0` characters, which can be used to\n * bypass header matching rules.\n *\n * ```proto\n * message MyString {\n * // The field `value` must have be a valid HTTP headers, but not enforced with strict rules.\n * string value = 1 [(buf.validate.field).string.strict = false];\n * }\n * ```\n *\n * @generated from field: optional bool strict = 25;\n */\n strict: boolean;\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyString {\n * string value = 1 [\n * (buf.validate.field).string.example = 1,\n * (buf.validate.field).string.example = 2\n * ];\n * }\n * ```\n *\n * @generated from field: repeated string example = 34;\n */\n example: string[];\n};\n\n/**\n * Describes the message buf.validate.StringRules.\n * Use `create(StringRulesSchema)` to create a new message.\n */\nexport const StringRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 18);\n\n/**\n * BytesRules describe the constraints applied to `bytes` values. These rules\n * may also be applied to the `google.protobuf.BytesValue` Well-Known-Type.\n *\n * @generated from message buf.validate.BytesRules\n */\nexport type BytesRules = Message<\"buf.validate.BytesRules\"> & {\n /**\n * `const` requires the field value to exactly match the specified bytes\n * value. If the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyBytes {\n * // value must be \"\\x01\\x02\\x03\\x04\"\n * bytes value = 1 [(buf.validate.field).bytes.const = \"\\x01\\x02\\x03\\x04\"];\n * }\n * ```\n *\n * @generated from field: optional bytes const = 1;\n */\n const: Uint8Array;\n\n /**\n * `len` requires the field value to have the specified length in bytes.\n * If the field value doesn't match, an error message is generated.\n *\n * ```proto\n * message MyBytes {\n * // value length must be 4 bytes.\n * optional bytes value = 1 [(buf.validate.field).bytes.len = 4];\n * }\n * ```\n *\n * @generated from field: optional uint64 len = 13;\n */\n len: bigint;\n\n /**\n * `min_len` requires the field value to have at least the specified minimum\n * length in bytes.\n * If the field value doesn't meet the requirement, an error message is generated.\n *\n * ```proto\n * message MyBytes {\n * // value length must be at least 2 bytes.\n * optional bytes value = 1 [(buf.validate.field).bytes.min_len = 2];\n * }\n * ```\n *\n * @generated from field: optional uint64 min_len = 2;\n */\n minLen: bigint;\n\n /**\n * `max_len` requires the field value to have at most the specified maximum\n * length in bytes.\n * If the field value exceeds the requirement, an error message is generated.\n *\n * ```proto\n * message MyBytes {\n * // value must be at most 6 bytes.\n * optional bytes value = 1 [(buf.validate.field).bytes.max_len = 6];\n * }\n * ```\n *\n * @generated from field: optional uint64 max_len = 3;\n */\n maxLen: bigint;\n\n /**\n * `pattern` requires the field value to match the specified regular\n * expression ([RE2 syntax](https://github.com/google/re2/wiki/Syntax)).\n * The value of the field must be valid UTF-8 or validation will fail with a\n * runtime error.\n * If the field value doesn't match the pattern, an error message is generated.\n *\n * ```proto\n * message MyBytes {\n * // value must match regex pattern \"^[a-zA-Z0-9]+$\".\n * optional bytes value = 1 [(buf.validate.field).bytes.pattern = \"^[a-zA-Z0-9]+$\"];\n * }\n * ```\n *\n * @generated from field: optional string pattern = 4;\n */\n pattern: string;\n\n /**\n * `prefix` requires the field value to have the specified bytes at the\n * beginning of the string.\n * If the field value doesn't meet the requirement, an error message is generated.\n *\n * ```proto\n * message MyBytes {\n * // value does not have prefix \\x01\\x02\n * optional bytes value = 1 [(buf.validate.field).bytes.prefix = \"\\x01\\x02\"];\n * }\n * ```\n *\n * @generated from field: optional bytes prefix = 5;\n */\n prefix: Uint8Array;\n\n /**\n * `suffix` requires the field value to have the specified bytes at the end\n * of the string.\n * If the field value doesn't meet the requirement, an error message is generated.\n *\n * ```proto\n * message MyBytes {\n * // value does not have suffix \\x03\\x04\n * optional bytes value = 1 [(buf.validate.field).bytes.suffix = \"\\x03\\x04\"];\n * }\n * ```\n *\n * @generated from field: optional bytes suffix = 6;\n */\n suffix: Uint8Array;\n\n /**\n * `contains` requires the field value to have the specified bytes anywhere in\n * the string.\n * If the field value doesn't meet the requirement, an error message is generated.\n *\n * ```protobuf\n * message MyBytes {\n * // value does not contain \\x02\\x03\n * optional bytes value = 1 [(buf.validate.field).bytes.contains = \"\\x02\\x03\"];\n * }\n * ```\n *\n * @generated from field: optional bytes contains = 7;\n */\n contains: Uint8Array;\n\n /**\n * `in` requires the field value to be equal to one of the specified\n * values. If the field value doesn't match any of the specified values, an\n * error message is generated.\n *\n * ```protobuf\n * message MyBytes {\n * // value must in [\"\\x01\\x02\", \"\\x02\\x03\", \"\\x03\\x04\"]\n * optional bytes value = 1 [(buf.validate.field).bytes.in = {\"\\x01\\x02\", \"\\x02\\x03\", \"\\x03\\x04\"}];\n * }\n * ```\n *\n * @generated from field: repeated bytes in = 8;\n */\n in: Uint8Array[];\n\n /**\n * `not_in` requires the field value to be not equal to any of the specified\n * values.\n * If the field value matches any of the specified values, an error message is\n * generated.\n *\n * ```proto\n * message MyBytes {\n * // value must not in [\"\\x01\\x02\", \"\\x02\\x03\", \"\\x03\\x04\"]\n * optional bytes value = 1 [(buf.validate.field).bytes.not_in = {\"\\x01\\x02\", \"\\x02\\x03\", \"\\x03\\x04\"}];\n * }\n * ```\n *\n * @generated from field: repeated bytes not_in = 9;\n */\n notIn: Uint8Array[];\n\n /**\n * WellKnown rules provide advanced constraints against common byte\n * patterns\n *\n * @generated from oneof buf.validate.BytesRules.well_known\n */\n wellKnown: {\n /**\n * `ip` ensures that the field `value` is a valid IP address (v4 or v6) in byte format.\n * If the field value doesn't meet this constraint, an error message is generated.\n *\n * ```proto\n * message MyBytes {\n * // value must be a valid IP address\n * optional bytes value = 1 [(buf.validate.field).bytes.ip = true];\n * }\n * ```\n *\n * @generated from field: bool ip = 10;\n */\n value: boolean;\n case: \"ip\";\n } | {\n /**\n * `ipv4` ensures that the field `value` is a valid IPv4 address in byte format.\n * If the field value doesn't meet this constraint, an error message is generated.\n *\n * ```proto\n * message MyBytes {\n * // value must be a valid IPv4 address\n * optional bytes value = 1 [(buf.validate.field).bytes.ipv4 = true];\n * }\n * ```\n *\n * @generated from field: bool ipv4 = 11;\n */\n value: boolean;\n case: \"ipv4\";\n } | {\n /**\n * `ipv6` ensures that the field `value` is a valid IPv6 address in byte format.\n * If the field value doesn't meet this constraint, an error message is generated.\n * ```proto\n * message MyBytes {\n * // value must be a valid IPv6 address\n * optional bytes value = 1 [(buf.validate.field).bytes.ipv6 = true];\n * }\n * ```\n *\n * @generated from field: bool ipv6 = 12;\n */\n value: boolean;\n case: \"ipv6\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyBytes {\n * bytes value = 1 [\n * (buf.validate.field).bytes.example = \"\\x01\\x02\",\n * (buf.validate.field).bytes.example = \"\\x02\\x03\"\n * ];\n * }\n * ```\n *\n * @generated from field: repeated bytes example = 14;\n */\n example: Uint8Array[];\n};\n\n/**\n * Describes the message buf.validate.BytesRules.\n * Use `create(BytesRulesSchema)` to create a new message.\n */\nexport const BytesRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 19);\n\n/**\n * EnumRules describe the constraints applied to `enum` values.\n *\n * @generated from message buf.validate.EnumRules\n */\nexport type EnumRules = Message<\"buf.validate.EnumRules\"> & {\n /**\n * `const` requires the field value to exactly match the specified enum value.\n * If the field value doesn't match, an error message is generated.\n *\n * ```proto\n * enum MyEnum {\n * MY_ENUM_UNSPECIFIED = 0;\n * MY_ENUM_VALUE1 = 1;\n * MY_ENUM_VALUE2 = 2;\n * }\n *\n * message MyMessage {\n * // The field `value` must be exactly MY_ENUM_VALUE1.\n * MyEnum value = 1 [(buf.validate.field).enum.const = 1];\n * }\n * ```\n *\n * @generated from field: optional int32 const = 1;\n */\n const: number;\n\n /**\n * `defined_only` requires the field value to be one of the defined values for\n * this enum, failing on any undefined value.\n *\n * ```proto\n * enum MyEnum {\n * MY_ENUM_UNSPECIFIED = 0;\n * MY_ENUM_VALUE1 = 1;\n * MY_ENUM_VALUE2 = 2;\n * }\n *\n * message MyMessage {\n * // The field `value` must be a defined value of MyEnum.\n * MyEnum value = 1 [(buf.validate.field).enum.defined_only = true];\n * }\n * ```\n *\n * @generated from field: optional bool defined_only = 2;\n */\n definedOnly: boolean;\n\n /**\n * `in` requires the field value to be equal to one of the\n * specified enum values. If the field value doesn't match any of the\n * specified values, an error message is generated.\n *\n * ```proto\n * enum MyEnum {\n * MY_ENUM_UNSPECIFIED = 0;\n * MY_ENUM_VALUE1 = 1;\n * MY_ENUM_VALUE2 = 2;\n * }\n *\n * message MyMessage {\n * // The field `value` must be equal to one of the specified values.\n * MyEnum value = 1 [(buf.validate.field).enum = { in: [1, 2]}];\n * }\n * ```\n *\n * @generated from field: repeated int32 in = 3;\n */\n in: number[];\n\n /**\n * `not_in` requires the field value to be not equal to any of the\n * specified enum values. If the field value matches one of the specified\n * values, an error message is generated.\n *\n * ```proto\n * enum MyEnum {\n * MY_ENUM_UNSPECIFIED = 0;\n * MY_ENUM_VALUE1 = 1;\n * MY_ENUM_VALUE2 = 2;\n * }\n *\n * message MyMessage {\n * // The field `value` must not be equal to any of the specified values.\n * MyEnum value = 1 [(buf.validate.field).enum = { not_in: [1, 2]}];\n * }\n * ```\n *\n * @generated from field: repeated int32 not_in = 4;\n */\n notIn: number[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * enum MyEnum {\n * MY_ENUM_UNSPECIFIED = 0;\n * MY_ENUM_VALUE1 = 1;\n * MY_ENUM_VALUE2 = 2;\n * }\n *\n * message MyMessage {\n * (buf.validate.field).enum.example = 1,\n * (buf.validate.field).enum.example = 2\n * }\n * ```\n *\n * @generated from field: repeated int32 example = 5;\n */\n example: number[];\n};\n\n/**\n * Describes the message buf.validate.EnumRules.\n * Use `create(EnumRulesSchema)` to create a new message.\n */\nexport const EnumRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 20);\n\n/**\n * RepeatedRules describe the constraints applied to `repeated` values.\n *\n * @generated from message buf.validate.RepeatedRules\n */\nexport type RepeatedRules = Message<\"buf.validate.RepeatedRules\"> & {\n /**\n * `min_items` requires that this field must contain at least the specified\n * minimum number of items.\n *\n * Note that `min_items = 1` is equivalent to setting a field as `required`.\n *\n * ```proto\n * message MyRepeated {\n * // value must contain at least 2 items\n * repeated string value = 1 [(buf.validate.field).repeated.min_items = 2];\n * }\n * ```\n *\n * @generated from field: optional uint64 min_items = 1;\n */\n minItems: bigint;\n\n /**\n * `max_items` denotes that this field must not exceed a\n * certain number of items as the upper limit. If the field contains more\n * items than specified, an error message will be generated, requiring the\n * field to maintain no more than the specified number of items.\n *\n * ```proto\n * message MyRepeated {\n * // value must contain no more than 3 item(s)\n * repeated string value = 1 [(buf.validate.field).repeated.max_items = 3];\n * }\n * ```\n *\n * @generated from field: optional uint64 max_items = 2;\n */\n maxItems: bigint;\n\n /**\n * `unique` indicates that all elements in this field must\n * be unique. This constraint is strictly applicable to scalar and enum\n * types, with message types not being supported.\n *\n * ```proto\n * message MyRepeated {\n * // repeated value must contain unique items\n * repeated string value = 1 [(buf.validate.field).repeated.unique = true];\n * }\n * ```\n *\n * @generated from field: optional bool unique = 3;\n */\n unique: boolean;\n\n /**\n * `items` details the constraints to be applied to each item\n * in the field. Even for repeated message fields, validation is executed\n * against each item unless skip is explicitly specified.\n *\n * ```proto\n * message MyRepeated {\n * // The items in the field `value` must follow the specified constraints.\n * repeated string value = 1 [(buf.validate.field).repeated.items = {\n * string: {\n * min_len: 3\n * max_len: 10\n * }\n * }];\n * }\n * ```\n *\n * @generated from field: optional buf.validate.FieldConstraints items = 4;\n */\n items?: FieldConstraints;\n};\n\n/**\n * Describes the message buf.validate.RepeatedRules.\n * Use `create(RepeatedRulesSchema)` to create a new message.\n */\nexport const RepeatedRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 21);\n\n/**\n * MapRules describe the constraints applied to `map` values.\n *\n * @generated from message buf.validate.MapRules\n */\nexport type MapRules = Message<\"buf.validate.MapRules\"> & {\n /**\n * Specifies the minimum number of key-value pairs allowed. If the field has\n * fewer key-value pairs than specified, an error message is generated.\n *\n * ```proto\n * message MyMap {\n * // The field `value` must have at least 2 key-value pairs.\n * map value = 1 [(buf.validate.field).map.min_pairs = 2];\n * }\n * ```\n *\n * @generated from field: optional uint64 min_pairs = 1;\n */\n minPairs: bigint;\n\n /**\n * Specifies the maximum number of key-value pairs allowed. If the field has\n * more key-value pairs than specified, an error message is generated.\n *\n * ```proto\n * message MyMap {\n * // The field `value` must have at most 3 key-value pairs.\n * map value = 1 [(buf.validate.field).map.max_pairs = 3];\n * }\n * ```\n *\n * @generated from field: optional uint64 max_pairs = 2;\n */\n maxPairs: bigint;\n\n /**\n * Specifies the constraints to be applied to each key in the field.\n *\n * ```proto\n * message MyMap {\n * // The keys in the field `value` must follow the specified constraints.\n * map value = 1 [(buf.validate.field).map.keys = {\n * string: {\n * min_len: 3\n * max_len: 10\n * }\n * }];\n * }\n * ```\n *\n * @generated from field: optional buf.validate.FieldConstraints keys = 4;\n */\n keys?: FieldConstraints;\n\n /**\n * Specifies the constraints to be applied to the value of each key in the\n * field. Message values will still have their validations evaluated unless\n * skip is specified here.\n *\n * ```proto\n * message MyMap {\n * // The values in the field `value` must follow the specified constraints.\n * map value = 1 [(buf.validate.field).map.values = {\n * string: {\n * min_len: 5\n * max_len: 20\n * }\n * }];\n * }\n * ```\n *\n * @generated from field: optional buf.validate.FieldConstraints values = 5;\n */\n values?: FieldConstraints;\n};\n\n/**\n * Describes the message buf.validate.MapRules.\n * Use `create(MapRulesSchema)` to create a new message.\n */\nexport const MapRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 22);\n\n/**\n * AnyRules describe constraints applied exclusively to the `google.protobuf.Any` well-known type.\n *\n * @generated from message buf.validate.AnyRules\n */\nexport type AnyRules = Message<\"buf.validate.AnyRules\"> & {\n /**\n * `in` requires the field's `type_url` to be equal to one of the\n * specified values. If it doesn't match any of the specified values, an error\n * message is generated.\n *\n * ```proto\n * message MyAny {\n * // The `value` field must have a `type_url` equal to one of the specified values.\n * google.protobuf.Any value = 1 [(buf.validate.field).any.in = [\"type.googleapis.com/MyType1\", \"type.googleapis.com/MyType2\"]];\n * }\n * ```\n *\n * @generated from field: repeated string in = 2;\n */\n in: string[];\n\n /**\n * 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.\n *\n * ```proto\n * message MyAny {\n * // The field `value` must not have a `type_url` equal to any of the specified values.\n * google.protobuf.Any value = 1 [(buf.validate.field).any.not_in = [\"type.googleapis.com/ForbiddenType1\", \"type.googleapis.com/ForbiddenType2\"]];\n * }\n * ```\n *\n * @generated from field: repeated string not_in = 3;\n */\n notIn: string[];\n};\n\n/**\n * Describes the message buf.validate.AnyRules.\n * Use `create(AnyRulesSchema)` to create a new message.\n */\nexport const AnyRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 23);\n\n/**\n * DurationRules describe the constraints applied exclusively to the `google.protobuf.Duration` well-known type.\n *\n * @generated from message buf.validate.DurationRules\n */\nexport type DurationRules = Message<\"buf.validate.DurationRules\"> & {\n /**\n * `const` dictates that the field must match the specified value of the `google.protobuf.Duration` type exactly.\n * If the field's value deviates from the specified value, an error message\n * will be generated.\n *\n * ```proto\n * message MyDuration {\n * // value must equal 5s\n * google.protobuf.Duration value = 1 [(buf.validate.field).duration.const = \"5s\"];\n * }\n * ```\n *\n * @generated from field: optional google.protobuf.Duration const = 2;\n */\n const?: Duration;\n\n /**\n * @generated from oneof buf.validate.DurationRules.less_than\n */\n lessThan: {\n /**\n * `lt` stipulates that the field must be less than the specified value of the `google.protobuf.Duration` type,\n * exclusive. If the field's value is greater than or equal to the specified\n * value, an error message will be generated.\n *\n * ```proto\n * message MyDuration {\n * // value must be less than 5s\n * google.protobuf.Duration value = 1 [(buf.validate.field).duration.lt = \"5s\"];\n * }\n * ```\n *\n * @generated from field: google.protobuf.Duration lt = 3;\n */\n value: Duration;\n case: \"lt\";\n } | {\n /**\n * `lte` indicates that the field must be less than or equal to the specified\n * value of the `google.protobuf.Duration` type, inclusive. If the field's value is greater than the specified value,\n * an error message will be generated.\n *\n * ```proto\n * message MyDuration {\n * // value must be less than or equal to 10s\n * google.protobuf.Duration value = 1 [(buf.validate.field).duration.lte = \"10s\"];\n * }\n * ```\n *\n * @generated from field: google.protobuf.Duration lte = 4;\n */\n value: Duration;\n case: \"lte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.DurationRules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the duration field value to be greater than the specified\n * value (exclusive). If the value of `gt` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyDuration {\n * // duration must be greater than 5s [duration.gt]\n * google.protobuf.Duration value = 1 [(buf.validate.field).duration.gt = { seconds: 5 }];\n *\n * // duration must be greater than 5s and less than 10s [duration.gt_lt]\n * google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gt: { seconds: 5 }, lt: { seconds: 10 } }];\n *\n * // duration must be greater than 10s or less than 5s [duration.gt_lt_exclusive]\n * google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gt: { seconds: 10 }, lt: { seconds: 5 } }];\n * }\n * ```\n *\n * @generated from field: google.protobuf.Duration gt = 5;\n */\n value: Duration;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the duration field value to be greater than or equal to the\n * specified value (exclusive). If the value of `gte` is larger than a\n * specified `lt` or `lte`, the range is reversed, and the field value must\n * be outside the specified range. If the field value doesn't meet the\n * required conditions, an error message is generated.\n *\n * ```proto\n * message MyDuration {\n * // duration must be greater than or equal to 5s [duration.gte]\n * google.protobuf.Duration value = 1 [(buf.validate.field).duration.gte = { seconds: 5 }];\n *\n * // duration must be greater than or equal to 5s and less than 10s [duration.gte_lt]\n * google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gte: { seconds: 5 }, lt: { seconds: 10 } }];\n *\n * // duration must be greater than or equal to 10s or less than 5s [duration.gte_lt_exclusive]\n * google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gte: { seconds: 10 }, lt: { seconds: 5 } }];\n * }\n * ```\n *\n * @generated from field: google.protobuf.Duration gte = 6;\n */\n value: Duration;\n case: \"gte\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `in` asserts that the field must be equal to one of the specified values of the `google.protobuf.Duration` type.\n * If the field's value doesn't correspond to any of the specified values,\n * an error message will be generated.\n *\n * ```proto\n * message MyDuration {\n * // value must be in list [1s, 2s, 3s]\n * google.protobuf.Duration value = 1 [(buf.validate.field).duration.in = [\"1s\", \"2s\", \"3s\"]];\n * }\n * ```\n *\n * @generated from field: repeated google.protobuf.Duration in = 7;\n */\n in: Duration[];\n\n /**\n * `not_in` denotes that the field must not be equal to\n * any of the specified values of the `google.protobuf.Duration` type.\n * If the field's value matches any of these values, an error message will be\n * generated.\n *\n * ```proto\n * message MyDuration {\n * // value must not be in list [1s, 2s, 3s]\n * google.protobuf.Duration value = 1 [(buf.validate.field).duration.not_in = [\"1s\", \"2s\", \"3s\"]];\n * }\n * ```\n *\n * @generated from field: repeated google.protobuf.Duration not_in = 8;\n */\n notIn: Duration[];\n\n /**\n * `example` specifies values that the field may have. These values SHOULD\n * conform to other constraints. `example` values will not impact validation\n * but may be used as helpful guidance on how to populate the given field.\n *\n * ```proto\n * message MyDuration {\n * google.protobuf.Duration value = 1 [\n * (buf.validate.field).duration.example = { seconds: 1 },\n * (buf.validate.field).duration.example = { seconds: 2 },\n * ];\n * }\n * ```\n *\n * @generated from field: repeated google.protobuf.Duration example = 9;\n */\n example: Duration[];\n};\n\n/**\n * Describes the message buf.validate.DurationRules.\n * Use `create(DurationRulesSchema)` to create a new message.\n */\nexport const DurationRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 24);\n\n/**\n * TimestampRules describe the constraints applied exclusively to the `google.protobuf.Timestamp` well-known type.\n *\n * @generated from message buf.validate.TimestampRules\n */\nexport type TimestampRules = Message<\"buf.validate.TimestampRules\"> & {\n /**\n * `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.\n *\n * ```proto\n * message MyTimestamp {\n * // value must equal 2023-05-03T10:00:00Z\n * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.const = {seconds: 1727998800}];\n * }\n * ```\n *\n * @generated from field: optional google.protobuf.Timestamp const = 2;\n */\n const?: Timestamp;\n\n /**\n * @generated from oneof buf.validate.TimestampRules.less_than\n */\n lessThan: {\n /**\n * requires the duration field value to be less than the specified value (field < value). If the field value doesn't meet the required conditions, an error message is generated.\n *\n * ```proto\n * message MyDuration {\n * // duration must be less than 'P3D' [duration.lt]\n * google.protobuf.Duration value = 1 [(buf.validate.field).duration.lt = { seconds: 259200 }];\n * }\n * ```\n *\n * @generated from field: google.protobuf.Timestamp lt = 3;\n */\n value: Timestamp;\n case: \"lt\";\n } | {\n /**\n * requires the timestamp field value to be less than or equal to the specified value (field <= value). If the field value doesn't meet the required conditions, an error message is generated.\n *\n * ```proto\n * message MyTimestamp {\n * // timestamp must be less than or equal to '2023-05-14T00:00:00Z' [timestamp.lte]\n * google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.lte = { seconds: 1678867200 }];\n * }\n * ```\n *\n * @generated from field: google.protobuf.Timestamp lte = 4;\n */\n value: Timestamp;\n case: \"lte\";\n } | {\n /**\n * `lt_now` specifies that this field, of the `google.protobuf.Timestamp` type, must be less than the current time. `lt_now` can only be used with the `within` rule.\n *\n * ```proto\n * message MyTimestamp {\n * // value must be less than now\n * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.lt_now = true];\n * }\n * ```\n *\n * @generated from field: bool lt_now = 7;\n */\n value: boolean;\n case: \"ltNow\";\n } | { case: undefined; value?: undefined };\n\n /**\n * @generated from oneof buf.validate.TimestampRules.greater_than\n */\n greaterThan: {\n /**\n * `gt` requires the timestamp field value to be greater than the specified\n * value (exclusive). If the value of `gt` is larger than a specified `lt`\n * or `lte`, the range is reversed, and the field value must be outside the\n * specified range. If the field value doesn't meet the required conditions,\n * an error message is generated.\n *\n * ```proto\n * message MyTimestamp {\n * // timestamp must be greater than '2023-01-01T00:00:00Z' [timestamp.gt]\n * google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.gt = { seconds: 1672444800 }];\n *\n * // timestamp must be greater than '2023-01-01T00:00:00Z' and less than '2023-01-02T00:00:00Z' [timestamp.gt_lt]\n * google.protobuf.Timestamp another_value = 2 [(buf.validate.field).timestamp = { gt: { seconds: 1672444800 }, lt: { seconds: 1672531200 } }];\n *\n * // timestamp must be greater than '2023-01-02T00:00:00Z' or less than '2023-01-01T00:00:00Z' [timestamp.gt_lt_exclusive]\n * google.protobuf.Timestamp other_value = 3 [(buf.validate.field).timestamp = { gt: { seconds: 1672531200 }, lt: { seconds: 1672444800 } }];\n * }\n * ```\n *\n * @generated from field: google.protobuf.Timestamp gt = 5;\n */\n value: Timestamp;\n case: \"gt\";\n } | {\n /**\n * `gte` requires the timestamp field value to be greater than or equal to the\n * specified value (exclusive). If the value of `gte` is larger than a\n * specified `lt` or `lte`, the range is reversed, and the field value\n * must be outside the specified range. If the field value doesn't meet\n * the required conditions, an error message is generated.\n *\n * ```proto\n * message MyTimestamp {\n * // timestamp must be greater than or equal to '2023-01-01T00:00:00Z' [timestamp.gte]\n * google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.gte = { seconds: 1672444800 }];\n *\n * // timestamp must be greater than or equal to '2023-01-01T00:00:00Z' and less than '2023-01-02T00:00:00Z' [timestamp.gte_lt]\n * google.protobuf.Timestamp another_value = 2 [(buf.validate.field).timestamp = { gte: { seconds: 1672444800 }, lt: { seconds: 1672531200 } }];\n *\n * // timestamp must be greater than or equal to '2023-01-02T00:00:00Z' or less than '2023-01-01T00:00:00Z' [timestamp.gte_lt_exclusive]\n * google.protobuf.Timestamp other_value = 3 [(buf.validate.field).timestamp = { gte: { seconds: 1672531200 }, lt: { seconds: 1672444800 } }];\n * }\n * ```\n *\n * @generated from field: google.protobuf.Timestamp gte = 6;\n */\n value: Timestamp;\n case: \"gte\";\n } | {\n /**\n * `gt_now` specifies that this field, of the `google.protobuf.Timestamp` type, must be greater than the current time. `gt_now` can only be used with the `within` rule.\n *\n * ```proto\n * message MyTimestamp {\n * // value must be greater than now\n * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.gt_now = true];\n * }\n * ```\n *\n * @generated from field: bool gt_now = 8;\n */\n value: boolean;\n case: \"gtNow\";\n } | { case: undefined; value?: undefined };\n\n /**\n * `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.\n *\n * ```proto\n * message MyTimestamp {\n * // value must be within 1 hour of now\n * google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.within = {seconds: 3600}];\n * }\n * ```\n *\n * @generated from field: optional google.protobuf.Duration within = 9;\n */\n within?: Duration;\n\n /**\n * @generated from field: repeated google.protobuf.Timestamp example = 10;\n */\n example: Timestamp[];\n};\n\n/**\n * Describes the message buf.validate.TimestampRules.\n * Use `create(TimestampRulesSchema)` to create a new message.\n */\nexport const TimestampRulesSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 25);\n\n/**\n * `Violations` is a collection of `Violation` messages. This message type is returned by\n * protovalidate when a proto message fails to meet the requirements set by the `Constraint` validation rules.\n * Each individual violation is represented by a `Violation` message.\n *\n * @generated from message buf.validate.Violations\n */\nexport type Violations = Message<\"buf.validate.Violations\"> & {\n /**\n * `violations` is a repeated field that contains all the `Violation` messages corresponding to the violations detected.\n *\n * @generated from field: repeated buf.validate.Violation violations = 1;\n */\n violations: Violation[];\n};\n\n/**\n * Describes the message buf.validate.Violations.\n * Use `create(ViolationsSchema)` to create a new message.\n */\nexport const ViolationsSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 26);\n\n/**\n * `Violation` represents a single instance where a validation rule, expressed\n * as a `Constraint`, was not met. It provides information about the field that\n * caused the violation, the specific constraint that wasn't fulfilled, and a\n * human-readable error message.\n *\n * ```json\n * {\n * \"fieldPath\": \"bar\",\n * \"constraintId\": \"foo.bar\",\n * \"message\": \"bar must be greater than 0\"\n * }\n * ```\n *\n * @generated from message buf.validate.Violation\n */\nexport type Violation = Message<\"buf.validate.Violation\"> & {\n /**\n * `field_path` is a machine-readable identifier that points to the specific field that failed the validation.\n * 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.\n *\n * @generated from field: optional string field_path = 1;\n */\n fieldPath: string;\n\n /**\n * `constraint_id` is the unique identifier of the `Constraint` that was not fulfilled.\n * This is the same `id` that was specified in the `Constraint` message, allowing easy tracing of which rule was violated.\n *\n * @generated from field: optional string constraint_id = 2;\n */\n constraintId: string;\n\n /**\n * `message` is a human-readable error message that describes the nature of the violation.\n * 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.\n *\n * @generated from field: optional string message = 3;\n */\n message: string;\n\n /**\n * `for_key` indicates whether the violation was caused by a map key, rather than a value.\n *\n * @generated from field: optional bool for_key = 4;\n */\n forKey: boolean;\n};\n\n/**\n * Describes the message buf.validate.Violation.\n * Use `create(ViolationSchema)` to create a new message.\n */\nexport const ViolationSchema: GenMessage = /*@__PURE__*/\n messageDesc(file_buf_validate_validate, 27);\n\n/**\n * Specifies how FieldConstraints.ignore behaves. See the documentation for\n * FieldConstraints.required for definitions of \"populated\" and \"nullable\".\n *\n * @generated from enum buf.validate.Ignore\n */\nexport enum Ignore {\n /**\n * Validation is only skipped if it's an unpopulated nullable fields.\n *\n * ```proto\n * syntax=\"proto3\";\n *\n * message Request {\n * // The uri rule applies to any value, including the empty string.\n * string foo = 1 [\n * (buf.validate.field).string.uri = true\n * ];\n *\n * // The uri rule only applies if the field is set, including if it's\n * // set to the empty string.\n * optional string bar = 2 [\n * (buf.validate.field).string.uri = true\n * ];\n *\n * // The min_items rule always applies, even if the list is empty.\n * repeated string baz = 3 [\n * (buf.validate.field).repeated.min_items = 3\n * ];\n *\n * // The custom CEL rule applies only if the field is set, including if\n * // it's the \"zero\" value of that message.\n * SomeMessage quux = 4 [\n * (buf.validate.field).cel = {/* ... *\\/}\n * ];\n * }\n * ```\n *\n * @generated from enum value: IGNORE_UNSPECIFIED = 0;\n */\n UNSPECIFIED = 0,\n\n /**\n * Validation is skipped if the field is unpopulated. This rule is redundant\n * if the field is already nullable. This value is equivalent behavior to the\n * deprecated ignore_empty rule.\n *\n * ```proto\n * syntax=\"proto3\n *\n * message Request {\n * // The uri rule applies only if the value is not the empty string.\n * string foo = 1 [\n * (buf.validate.field).string.uri = true,\n * (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED\n * ];\n *\n * // IGNORE_IF_UNPOPULATED is equivalent to IGNORE_UNSPECIFIED in this\n * // case: the uri rule only applies if the field is set, including if\n * // it's set to the empty string.\n * optional string bar = 2 [\n * (buf.validate.field).string.uri = true,\n * (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED\n * ];\n *\n * // The min_items rule only applies if the list has at least one item.\n * repeated string baz = 3 [\n * (buf.validate.field).repeated.min_items = 3,\n * (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED\n * ];\n *\n * // IGNORE_IF_UNPOPULATED is equivalent to IGNORE_UNSPECIFIED in this\n * // case: the custom CEL rule applies only if the field is set, including\n * // if it's the \"zero\" value of that message.\n * SomeMessage quux = 4 [\n * (buf.validate.field).cel = {/* ... *\\/},\n * (buf.validate.field).ignore = IGNORE_IF_UNPOPULATED\n * ];\n * }\n * ```\n *\n * @generated from enum value: IGNORE_IF_UNPOPULATED = 1;\n */\n IF_UNPOPULATED = 1,\n\n /**\n * Validation is skipped if the field is unpopulated or if it is a nullable\n * field populated with its default value. This is typically the zero or\n * empty value, but proto2 scalars support custom defaults. For messages, the\n * default is a non-null message with all its fields unpopulated.\n *\n * ```proto\n * syntax=\"proto3\n *\n * message Request {\n * // IGNORE_IF_DEFAULT_VALUE is equivalent to IGNORE_IF_UNPOPULATED in\n * // this case; the uri rule applies only if the value is not the empty\n * // string.\n * string foo = 1 [\n * (buf.validate.field).string.uri = true,\n * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE\n * ];\n *\n * // The uri rule only applies if the field is set to a value other than\n * // the empty string.\n * optional string bar = 2 [\n * (buf.validate.field).string.uri = true,\n * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE\n * ];\n *\n * // IGNORE_IF_DEFAULT_VALUE is equivalent to IGNORE_IF_UNPOPULATED in\n * // this case; the min_items rule only applies if the list has at least\n * // one item.\n * repeated string baz = 3 [\n * (buf.validate.field).repeated.min_items = 3,\n * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE\n * ];\n *\n * // The custom CEL rule only applies if the field is set to a value other\n * // than an empty message (i.e., fields are unpopulated).\n * SomeMessage quux = 4 [\n * (buf.validate.field).cel = {/* ... *\\/},\n * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE\n * ];\n * }\n * ```\n *\n * This rule is affected by proto2 custom default values:\n *\n * ```proto\n * syntax=\"proto2\";\n *\n * message Request {\n * // The gt rule only applies if the field is set and it's value is not\n * the default (i.e., not -42). The rule even applies if the field is set\n * to zero since the default value differs.\n * optional int32 value = 1 [\n * default = -42,\n * (buf.validate.field).int32.gt = 0,\n * (buf.validate.field).ignore = IGNORE_IF_DEFAULT_VALUE\n * ];\n * }\n *\n * @generated from enum value: IGNORE_IF_DEFAULT_VALUE = 2;\n */\n IF_DEFAULT_VALUE = 2,\n\n /**\n * The validation rules of this field will be skipped and not evaluated. This\n * is useful for situations that necessitate turning off the rules of a field\n * containing a message that may not make sense in the current context, or to\n * temporarily disable constraints during development.\n *\n * ```proto\n * message MyMessage {\n * // The field's rules will always be ignored, including any validation's\n * // on value's fields.\n * MyOtherMessage value = 1 [\n * (buf.validate.field).ignore = IGNORE_ALWAYS];\n * }\n * ```\n *\n * @generated from enum value: IGNORE_ALWAYS = 3;\n */\n ALWAYS = 3,\n\n /**\n * Deprecated: Use IGNORE_IF_UNPOPULATED instead. TODO: Remove this value pre-v1.\n *\n * @generated from enum value: IGNORE_EMPTY = 1 [deprecated = true];\n * @deprecated\n */\n EMPTY = 1,\n\n /**\n * Deprecated: Use IGNORE_IF_DEFAULT_VALUE. TODO: Remove this value pre-v1.\n *\n * @generated from enum value: IGNORE_DEFAULT = 2 [deprecated = true];\n * @deprecated\n */\n DEFAULT = 2,\n}\n\n/**\n * Describes the enum buf.validate.Ignore.\n */\nexport const IgnoreSchema: GenEnum = /*@__PURE__*/\n enumDesc(file_buf_validate_validate, 0);\n\n/**\n * WellKnownRegex contain some well-known patterns.\n *\n * @generated from enum buf.validate.KnownRegex\n */\nexport enum KnownRegex {\n /**\n * @generated from enum value: KNOWN_REGEX_UNSPECIFIED = 0;\n */\n UNSPECIFIED = 0,\n\n /**\n * HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2).\n *\n * @generated from enum value: KNOWN_REGEX_HTTP_HEADER_NAME = 1;\n */\n HTTP_HEADER_NAME = 1,\n\n /**\n * HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4).\n *\n * @generated from enum value: KNOWN_REGEX_HTTP_HEADER_VALUE = 2;\n */\n HTTP_HEADER_VALUE = 2,\n}\n\n/**\n * Describes the enum buf.validate.KnownRegex.\n */\nexport const KnownRegexSchema: GenEnum = /*@__PURE__*/\n enumDesc(file_buf_validate_validate, 1);\n\n/**\n * Rules specify the validations to be performed on this message. By default,\n * no validation is performed against a message.\n *\n * @generated from extension: optional buf.validate.MessageConstraints message = 1159;\n */\nexport const message: GenExtension = /*@__PURE__*/\n extDesc(file_buf_validate_validate, 0);\n\n/**\n * Rules specify the validations to be performed on this oneof. By default,\n * no validation is performed against a oneof.\n *\n * @generated from extension: optional buf.validate.OneofConstraints oneof = 1159;\n */\nexport const oneof: GenExtension = /*@__PURE__*/\n extDesc(file_buf_validate_validate, 1);\n\n/**\n * Rules specify the validations to be performed on this field. By default,\n * no validation is performed against a field.\n *\n * @generated from extension: optional buf.validate.FieldConstraints field = 1159;\n */\nexport const field: GenExtension = /*@__PURE__*/\n extDesc(file_buf_validate_validate, 2);\n\n/**\n * Specifies predefined rules. When extending a standard constraint message,\n * this adds additional CEL expressions that apply when the extension is used.\n *\n * ```proto\n * extend buf.validate.Int32Rules {\n * bool is_zero [(buf.validate.predefined).cel = {\n * id: \"int32.is_zero\",\n * message: \"value must be zero\",\n * expression: \"!rule || this == 0\",\n * }];\n * }\n *\n * message Foo {\n * int32 reserved = 1 [(buf.validate.field).int32.(is_zero) = true];\n * }\n * ```\n *\n * @generated from extension: optional buf.validate.PredefinedConstraints predefined = 1160;\n */\nexport const predefined: GenExtension = /*@__PURE__*/\n extDesc(file_buf_validate_validate, 3);\n\n"],"names":["file_buf_validate_validate","ConstraintSchema","MessageConstraintsSchema","OneofConstraintsSchema","FieldConstraintsSchema","PredefinedConstraintsSchema","FloatRulesSchema","DoubleRulesSchema","Int32RulesSchema","Int64RulesSchema","UInt32RulesSchema","UInt64RulesSchema","SInt32RulesSchema","SInt64RulesSchema","Fixed32RulesSchema","Fixed64RulesSchema","SFixed32RulesSchema","SFixed64RulesSchema","BoolRulesSchema","StringRulesSchema","BytesRulesSchema","EnumRulesSchema","RepeatedRulesSchema","MapRulesSchema","AnyRulesSchema","DurationRulesSchema","TimestampRulesSchema","ViolationsSchema","ViolationSchema","Ignore","IgnoreSchema","KnownRegex","KnownRegexSchema","message","oneof","field","predefined"],"sourceRoot":""}