1// Copyright 2023 Buf Technologies, Inc.   2//   3// Licensed under the Apache License, Version 2.0 (the "License");   4// you may not use this file except in compliance with the License.   5// You may obtain a copy of the License at   6//   7//      http://www.apache.org/licenses/LICENSE-2.0   8//   9// Unless required by applicable law or agreed to in writing, software  10// distributed under the License is distributed on an "AS IS" BASIS,  11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  12// See the License for the specific language governing permissions and  13// limitations under the License.  14  15syntax = "proto3";  16  17package buf.validate;  18  19import "buf/validate/expression.proto";  20import "buf/validate/priv/private.proto";  21import "google/protobuf/descriptor.proto";  22import "google/protobuf/duration.proto";  23import "google/protobuf/timestamp.proto";  24  25option go_package = "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate";  26  27// MessageOptions is an extension to google.protobuf.MessageOptions. It allows  28// the addition of validation rules at the message level. These rules can be  29// applied to incoming messages to ensure they meet certain criteria before  30// being processed.  31extend google.protobuf.MessageOptions {  32  // Rules specify the validations to be performed on this message. By default,  33  // no validation is performed against a message.  34  optional MessageConstraints message = 51071;  35}  36  37// OneofOptions is an extension to google.protobuf.OneofOptions. It allows  38// the addition of validation rules on a oneof. These rules can be  39// applied to incoming messages to ensure they meet certain criteria before  40// being processed.  41extend google.protobuf.OneofOptions {  42  // Rules specify the validations to be performed on this oneof. By default,  43  // no validation is performed against a oneof.  44  optional OneofConstraints oneof = 51071;  45}  46  47// FieldOptions is an extension to google.protobuf.FieldOptions. It allows  48// the addition of validation rules at the field level. These rules can be  49// applied to incoming messages to ensure they meet certain criteria before  50// being processed.  51extend google.protobuf.FieldOptions {  52  // Rules specify the validations to be performed on this field. By default,  53  // no validation is performed against a field.  54  optional FieldConstraints field = 51071;  55}  56  57// MessageConstraints represents validation rules that are applied to the entire message.  58// It includes disabling options and a list of Constraint messages representing Common Expression Language (CEL) validation rules.  59message MessageConstraints {  60  // disabled is a boolean flag that, when set to true, nullifies any validation rules for this message.  61  // This includes any fields within the message that would otherwise support validation.  62  //  63  // ```proto  64  // message MyMessage {  65  //   // validation will be bypassed for this message  66  //   option (buf.validate.message).disabled = true;  67  // }  68  // ```  69  optional bool disabled = 1;  70  71  // cel is a repeated field of type Constraint. Each Constraint specifies a validation rule to be applied to this message.  72  // These constraints are written in Common Expression Language (CEL) syntax. For more information on  73  // CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).  74  //  75  //  76  //```proto  77  //message MyMessage {  78  //  // The field `foo` must be greater than 42.  79  //  option (buf.validate.message).cel = {  80  //    id: "my_message.value",  81  //    message: "value must be greater than 42",  82  //    expression: "this.foo > 42",  83  //  };  84  //  optional int32 foo = 1;  85  //}  86  //```  87  repeated Constraint cel = 3;  88}  89  90// The `OneofConstraints` message type enables you to manage constraints for  91// oneof fields in your protobuf messages. Use the `required` constraint to ensure  92// that exactly one of the fields within a oneof is set; validation will fail  93// if none of the fields in the oneof are set:  94message OneofConstraints {  95  //`required` is an optional boolean attribute that ensures that  96  //exactly one of the field options in a oneof is set; validation fails if  97  //no fields in the oneof are set.  98  //  99  //```proto 100  //message MyMessage { 101  //  oneof value { 102  //    // The field `a` or `b` must be set. 103  //    option [(buf.validate.oneof).required = true] 104  //    optional string a = 1; 105  //    optional string b = 2; 106  //  } 107  //} 108  //``` 109  optional bool required = 1; 110} 111 112// FieldRules encapsulates the rules for each type of field. Depending on the 113// field, the correct set should be used to ensure proper validations. 114message FieldConstraints { 115  // `Constraint` is a repeated field used to represent a textual expression 116  // in the Common Expression Language (CEL) syntax. For more information on 117  // CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md). 118  // 119  //```proto 120  //message MyMessage { 121  //  // The field `value` must be greater than 42. 122  //  optional int32 value = 1 [(buf.validate.field).cel = { 123  //    id: "my_message.value", 124  //    message: "value must be greater than 42", 125  //    expression: "this > 42", 126  //  }]; 127  //} 128  //``` 129  repeated Constraint cel = 23; 130  //`skipped` is an optional boolean attribute that specifies that the 131  //validation rules of this field should not be evaluated. If skipped is set to 132  //true, any validation rules set for the field will be ignored. 133  // 134  //```proto 135  //message MyMessage { 136  //  // The field `value` must not be set. 137  //  optional MyOtherMessage value = 1 [(buf.validate.field).skipped = true]; 138  //} 139  //``` 140  bool skipped = 24; 141  //`required` is an optional boolean attribute that specifies that 142  //this field must be set. If required is set to true, the field value must 143  //not be empty; otherwise, an error message will be generated. 144  // 145  //```proto 146  //message MyMessage { 147  //  // The field `value` must be set. 148  //  optional MyOtherMessage value = 1 [(buf.validate.field).required = true]; 149  //} 150  //``` 151  bool required = 25; 152  //`ignore_empty` specifies that the validation rules of this field should be 153  //evaluated only if the field isn't empty. If the field is empty, no validation 154  //rules are applied. 155  // 156  //```proto 157  //message MyRepeated { 158  //  // The field `value` validation rules should be evaluated only if the field isn't empty. 159  //  repeated string value = 1 [(buf.validate.field).ignore_empty = true]; 160  //} 161  //``` 162  bool ignore_empty = 26; 163  oneof type { 164    // Scalar Field Types 165    FloatRules float = 1; 166    DoubleRules double = 2; 167    Int32Rules int32 = 3; 168    Int64Rules int64 = 4; 169    UInt32Rules uint32 = 5; 170    UInt64Rules uint64 = 6; 171    SInt32Rules sint32 = 7; 172    SInt64Rules sint64 = 8; 173    Fixed32Rules fixed32 = 9; 174    Fixed64Rules fixed64 = 10; 175    SFixed32Rules sfixed32 = 11; 176    SFixed64Rules sfixed64 = 12; 177    BoolRules bool = 13; 178    StringRules string = 14; 179    BytesRules bytes = 15; 180 181    // Complex Field Types 182    EnumRules enum = 16; 183    RepeatedRules repeated = 18; 184    MapRules map = 19; 185 186    // Well-Known Field Types 187    AnyRules any = 20; 188    DurationRules duration = 21; 189    TimestampRules timestamp = 22; 190  } 191} 192 193// FloatRules describes the constraints applied to `float` values. These 194// rules may also be applied to the `google.protobuf.FloatValue` Well-Known-Type. 195message FloatRules { 196  //`const` requires the field value to exactly match the specified value. If 197  // the field value doesn't match, an error message is generated. 198  // 199  //```proto 200  //message MyFloat { 201  //  // value must equal 42.0 202  //   float value = 1 [(buf.validate.field).float.const = 42.0]; 203  //} 204  //``` 205  optional float const = 1 [(priv.field).cel = { 206    id: "float.const", 207    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''", 208  }]; 209 210  //`lt` requires the field value to be less than the specified value (field < 211  // value). If the field value is equal to or greater than the specified value, 212  // an error message is generated. 213  // 214  //```proto 215  //message MyFloat { 216  //  // value must be less than 10.0 217  //   float value = 1 [(buf.validate.field).float.lt = 10.0]; 218  //} 219  //``` 220  optional float lt = 2 [(priv.field).cel = { 221    id: "float.lt", 222    expression: 223      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt" 224      "? 'value must be less than %s'.format([rules.lt]) : ''" 225  }]; 226 227  //`lte` requires the field value to be less than or equal to the specified 228  // value (field <= value). If the field value is greater than the specified 229  // value, an error message is generated. 230  // 231  //```proto 232  //message MyFloat { 233  //  // value must be less than or equal to 10.0 234  //   float value = 1 [(buf.validate.field).float.lte = 10.0]; 235  //} 236  //``` 237  optional float lte = 3 [(priv.field).cel = { 238    id: "float.lte", 239    expression: 240      "!has(rules.gte) && !has(rules.gt) && this > rules.lte" 241      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''" 242  }]; 243 244  //`gt` requires the field value to be greater than the specified value 245  // (exclusive). If the value of `gt` is larger than a specified `lt` or 246  // `lte`, the range is reversed, and the field value must be outside the 247  // specified range. If the field value doesn't meet the required conditions, 248  // an error message is generated. 249  // 250  //```proto 251  //message MyFloat { 252  //  // value must be greater than 5.0 [float.gt] 253  //  float value = 1 [(buf.validate.field).float.gt = 5.0]; 254  // 255  //  // value must be greater than 5 and less than 10.0 [float.gt_lt] 256  //  float other_value = 2 [(buf.validate.field).float = { gt: 5.0, lt: 10.0 }]; 257  // 258  //  // value must be greater than 10 or less than 5.0 [float.gt_lt_exclusive] 259  //  float another_value = 3 [(buf.validate.field).float = { gt: 10.0, lt: 5.0 }]; 260  //} 261  //``` 262  optional float gt = 4 [ 263    (priv.field).cel = { 264      id: "float.gt", 265      expression: 266        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt" 267        "? 'value must be greater than %s'.format([rules.gt]) : ''" 268    }, 269    (priv.field).cel = { 270      id: "float.gt_lt", 271      expression: 272        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)" 273        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''" 274    }, 275    (priv.field).cel = { 276      id: "float.gt_lt_exclusive", 277      expression: 278        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)" 279        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''" 280    }, 281    (priv.field).cel = { 282      id: "float.gt_lte", 283      expression: 284        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)" 285        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''" 286    }, 287    (priv.field).cel = { 288      id: "float.gt_lte_exclusive", 289      expression: 290        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)" 291        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''" 292    } 293  ]; 294 295  //`gte` requires the field value to be greater than or equal to the specified 296  // value (exclusive). If the value of `gte` is larger than a specified `lt` 297  // or `lte`, the range is reversed, and the field value must be outside the 298  // specified range. If the field value doesn't meet the required conditions, 299  // an error message is generated. 300  // 301  //```proto 302  //message MyFloat { 303  //  // value must be greater than or equal to 5.0 [float.gte] 304  //  float value = 1 [(buf.validate.field).float.gte = 5.0]; 305  // 306  //  // value must be greater than or equal to 5.0 and less than 10.0 [float.gte_lt] 307  //  float other_value = 2 [(buf.validate.field).float = { gte: 5.0, lt: 10.0 }]; 308  // 309  //  // value must be greater than or equal to 10.0 or less than 5.0 [float.gte_lt_exclusive] 310  //  float another_value = 3 [(buf.validate.field).float = { gte: 10.0, lt: 5.0 }]; 311  //} 312  //``` 313  optional float gte = 5 [ 314    (priv.field).cel = { 315      id: "float.gte", 316      expression: 317        "!has(rules.lt) && !has(rules.lte) && this < rules.gte" 318        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''" 319    }, 320    (priv.field).cel = { 321      id: "float.gte_lt", 322      expression: 323        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)" 324        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''" 325    }, 326    (priv.field).cel = { 327      id: "float.gte_lt_exclusive", 328      expression: 329        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)" 330        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''" 331    }, 332    (priv.field).cel = { 333      id: "float.gte_lte", 334      expression: 335        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)" 336        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''" 337    }, 338    (priv.field).cel = { 339      id: "float.gte_lte_exclusive", 340      expression: 341        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)" 342        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''" 343    } 344  ]; 345 346  //`in` requires the field value to be equal to one of the specified values. 347  // If the field value isn't one of the specified values, an error message 348  // is generated. 349  // 350  //```proto 351  //message MyFloat { 352  //  // value must be in list [1.0, 2.0, 3.0] 353  //  repeated float value = 1 (buf.validate.field).float = { in: [1.0, 2.0, 3.0] }; 354  //} 355  //``` 356  repeated float in = 6 [(priv.field).cel = { 357    id: "float.in", 358    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''", 359  }]; 360 361  //`in` requires the field value to not be equal to any of the specified 362  // values. If the field value is one of the specified values, an error 363  // message is generated. 364  // 365  //```proto 366  //message MyFloat { 367  //  // value must not be in list [1.0, 2.0, 3.0] 368  //  repeated float value = 1 (buf.validate.field).float = { not_in: [1.0, 2.0, 3.0] }; 369  //} 370  //``` 371  repeated float not_in = 7 [(priv.field).cel = { 372    id: "float.not_in", 373    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''", 374  }]; 375} 376 377// DoubleRules describes the constraints applied to `double` values. These 378// rules may also be applied to the `google.protobuf.DoubleValue` Well-Known-Type. 379message DoubleRules { 380  //`const` requires the field value to exactly match the specified value. If 381  // the field value doesn't match, an error message is generated. 382  // 383  //```proto 384  //message MyDouble { 385  //  // value must equal 42.0 386  //   double value = 1 [(buf.validate.field).double.const = 42.0]; 387  //} 388  //``` 389  optional double const = 1 [(priv.field).cel = { 390    id: "double.const", 391    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''", 392  }]; 393 394  // `lt` requires the field value to be less than the specified value (field < 395  // value). If the field value is equal to or greater than the specified 396  // value, an error message is generated. 397  // 398  //```proto 399  //message MyDouble { 400  //  // value must be less than 10.0 401  //   double value = 1 [(buf.validate.field).double.lt = 10.0]; 402  //} 403  //``` 404  optional double lt = 2 [(priv.field).cel = { 405    id: "double.lt", 406    expression: 407      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt" 408      "? 'value must be less than %s'.format([rules.lt]) : ''" 409  }]; 410 411  //`lte` requires the field value to be less than or equal to the specified value 412  // (field <= value). If the field value is greater than the specified value, 413  // an error message is generated. 414  // 415  //```proto 416  //message MyDouble { 417  //  // value must be less than or equal to 10.0 418  //   double value = 1 [(buf.validate.field).double.lte = 10.0]; 419  //} 420  //``` 421  optional double lte = 3 [(priv.field).cel = { 422    id: "double.lte", 423    expression: 424      "!has(rules.gte) && !has(rules.gt) && this > rules.lte" 425      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''" 426  }]; 427 428  // `gt` requires the field value to be greater than the specified value 429  // (exclusive). If the value of `gt` is larger than a specified `lt` or `lte`, 430  // the range is reversed, and the field value must be outside the specified 431  // range. If the field value doesn't meet the required conditions, an error 432  // message is generated. 433  // 434  //```proto 435  //message MyDouble { 436  //  // value must be greater than 5.0 [double.gt] 437  //  double value = 1 [(buf.validate.field).double.gt = 5.0]; 438  // 439  //  // value must be greater than 5 and less than 10.0 [double.gt_lt] 440  //  double other_value = 2 [(buf.validate.field).double = { gt: 5.0, lt: 10.0 }]; 441  // 442  //  // value must be greater than 10 or less than 5.0 [double.gt_lt_exclusive] 443  //  double another_value = 3 [(buf.validate.field).double = { gt: 10.0, lt: 5.0 }]; 444  //} 445  //``` 446  optional double gt = 4 [ 447    (priv.field).cel = { 448      id: "double.gt", 449      expression: 450        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt" 451        "? 'value must be greater than %s'.format([rules.gt]) : ''" 452    }, 453    (priv.field).cel = { 454      id: "double.gt_lt", 455      expression: 456        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)" 457        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''" 458    }, 459    (priv.field).cel = { 460      id: "double.gt_lt_exclusive", 461      expression: 462        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)" 463        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''" 464    }, 465    (priv.field).cel = { 466      id: "double.gt_lte", 467      expression: 468        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)" 469        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''" 470    }, 471    (priv.field).cel = { 472      id: "double.gt_lte_exclusive", 473      expression: 474        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)" 475        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''" 476    } 477  ]; 478 479  // `gte` requires the field value to be greater than or equal to the specified 480  // value (exclusive). If the value of `gte` is larger than a specified `lt` or 481  // `lte`, the range is reversed, and the field value must be outside the 482  // specified range. If the field value doesn't meet the required conditions, 483  // an error message is generated. 484  // 485  //```proto 486  //message MyDouble { 487  //  // value must be greater than or equal to 5.0 [double.gte] 488  //  double value = 1 [(buf.validate.field).double.gte = 5.0]; 489  // 490  //  // value must be greater than or equal to 5.0 and less than 10.0 [double.gte_lt] 491  //  double other_value = 2 [(buf.validate.field).double = { gte: 5.0, lt: 10.0 }]; 492  // 493  //  // value must be greater than or equal to 10.0 or less than 5.0 [double.gte_lt_exclusive] 494  //  double another_value = 3 [(buf.validate.field).double = { gte: 10.0, lt: 5.0 }]; 495  //} 496  //``` 497  optional double gte = 5 [ 498    (priv.field).cel = { 499      id: "double.gte", 500      expression: 501        "!has(rules.lt) && !has(rules.lte) && this < rules.gte" 502        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''" 503    }, 504    (priv.field).cel = { 505      id: "double.gte_lt", 506      expression: 507        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)" 508        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''" 509    }, 510    (priv.field).cel = { 511      id: "double.gte_lt_exclusive", 512      expression: 513        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)" 514        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''" 515    }, 516    (priv.field).cel = { 517      id: "double.gte_lte", 518      expression: 519        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)" 520        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''" 521    }, 522    (priv.field).cel = { 523      id: "double.gte_lte_exclusive", 524      expression: 525        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)" 526        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''" 527    } 528  ]; 529 530  // `in` requires the field value to be equal to one of the specified values. 531  // If the field value isn't one of the specified values, an error message is 532  // generated. 533  // 534  //```proto 535  //message MyDouble { 536  //  // value must be in list [1.0, 2.0, 3.0] 537  //  repeated double value = 1 (buf.validate.field).double = { in: [1.0, 2.0, 3.0] }; 538  //} 539  //``` 540  repeated double in = 6 [(priv.field).cel = { 541    id: "double.in", 542    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''", 543  }]; 544 545  //`not_in` requires the field value to not be equal to any of the specified 546  // values. If the field value is one of the specified values, an error 547  // message is generated. 548  // 549  //```proto 550  //message MyDouble { 551  //  // value must not be in list [1.0, 2.0, 3.0] 552  //  repeated double value = 1 (buf.validate.field).double = { not_in: [1.0, 2.0, 3.0] }; 553  //} 554  //``` 555  repeated double not_in = 7 [(priv.field).cel = { 556    id: "double.not_in", 557    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''", 558  }]; 559} 560 561// Int32Rules describes the constraints applied to `int32` values. These 562// rules may also be applied to the `google.protobuf.Int32Value` Well-Known-Type. 563message Int32Rules { 564  //`const` requires the field value to exactly match the specified value. If 565  // the field value doesn't match, an error message is generated. 566  // 567  //```proto 568  //message MyInt32 { 569  //  // value must equal 42 570  //   int32 value = 1 [(buf.validate.field).int32.const = 42]; 571  //} 572  //``` 573  optional int32 const = 1 [(priv.field).cel = { 574    id: "int32.const", 575    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''", 576  }]; 577 578  // `lt` requires the field value to be less than the specified value (field 579  // < value). If the field value is equal to or greater than the specified 580  // value, an error message is generated. 581  // 582  //```proto 583  //message MyInt32 { 584  //  // value must be less than 10 585  //   int32 value = 1 [(buf.validate.field).int32.lt = 10]; 586  //} 587  //``` 588  optional int32 lt = 2 [(priv.field).cel = { 589    id: "int32.lt", 590    expression: 591      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt" 592      "? 'value must be less than %s'.format([rules.lt]) : ''" 593  }]; 594 595  //`lte` requires the field value to be less than or equal to the specified 596  // value (field <= value). If the field value is greater than the specified 597  // value, an error message is generated. 598  // 599  //```proto 600  //message MyInt32 { 601  //  // value must be less than or equal to 10 602  //   int32 value = 1 [(buf.validate.field).int32.lte = 10]; 603  //} 604  //``` 605  optional int32 lte = 3 [(priv.field).cel = { 606    id: "int32.lte", 607    expression: 608      "!has(rules.gte) && !has(rules.gt) && this > rules.lte" 609      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''" 610  }]; 611 612  //`gt` requires the field value to be greater than the specified value 613  // (exclusive). If the value of `gt` is larger than a specified `lt` or 614  // `lte`, the range is reversed, and the field value must be outside the 615  // specified range. If the field value doesn't meet the required conditions, 616  // an error message is generated. 617  // 618  //```proto 619  //message MyInt32 { 620  //  // value must be greater than 5 [int32.gt] 621  //  int32 value = 1 [(buf.validate.field).int32.gt = 5]; 622  // 623  //  // value must be greater than 5 and less than 10 [int32.gt_lt] 624  //  int32 other_value = 2 [(buf.validate.field).int32 = { gt: 5, lt: 10 }]; 625  // 626  //  // value must be greater than 10 or less than 5 [int32.gt_lt_exclusive] 627  //  int32 another_value = 3 [(buf.validate.field).int32 = { gt: 10, lt: 5 }]; 628  //} 629  //``` 630  optional int32 gt = 4 [ 631    (priv.field).cel = { 632      id: "int32.gt", 633      expression: 634        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt" 635        "? 'value must be greater than %s'.format([rules.gt]) : ''" 636    }, 637    (priv.field).cel = { 638      id: "int32.gt_lt", 639      expression: 640        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)" 641        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''" 642    }, 643    (priv.field).cel = { 644      id: "int32.gt_lt_exclusive", 645      expression: 646        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)" 647        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''" 648    }, 649    (priv.field).cel = { 650      id: "int32.gt_lte", 651      expression: 652        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)" 653        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''" 654    }, 655    (priv.field).cel = { 656      id: "int32.gt_lte_exclusive", 657      expression: 658        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)" 659        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''" 660    } 661  ]; 662 663  //`gte` requires the field value to be greater than or equal to the specified value 664  // (exclusive). If the value of `gte` is larger than a specified `lt` or 665  // `lte`, the range is reversed, and the field value must be outside the 666  // specified range. If the field value doesn't meet the required conditions, 667  // an error message is generated. 668  // 669  //```proto 670  //message MyInt32 { 671  //  // value must be greater than or equal to 5 [int32.gte] 672  //  int32 value = 1 [(buf.validate.field).int32.gte = 5]; 673  // 674  //  // value must be greater than or equal to 5 and less than 10 [int32.gte_lt] 675  //  int32 other_value = 2 [(buf.validate.field).int32 = { gte: 5, lt: 10 }]; 676  // 677  //  // value must be greater than or equal to 10 or less than 5 [int32.gte_lt_exclusive] 678  //  int32 another_value = 3 [(buf.validate.field).int32 = { gte: 10, lt: 5 }]; 679  //} 680  //``` 681  optional int32 gte = 5 [ 682    (priv.field).cel = { 683      id: "int32.gte", 684      expression: 685        "!has(rules.lt) && !has(rules.lte) && this < rules.gte" 686        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''" 687    }, 688    (priv.field).cel = { 689      id: "int32.gte_lt", 690      expression: 691        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)" 692        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''" 693    }, 694    (priv.field).cel = { 695      id: "int32.gte_lt_exclusive", 696      expression: 697        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)" 698        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''" 699    }, 700    (priv.field).cel = { 701      id: "int32.gte_lte", 702      expression: 703        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)" 704        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''" 705    }, 706    (priv.field).cel = { 707      id: "int32.gte_lte_exclusive", 708      expression: 709        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)" 710        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''" 711    } 712  ]; 713 714  //`in` requires the field value to be equal to one of the specified values. 715  // If the field value isn't one of the specified values, an error message is 716  // generated. 717  // 718  //```proto 719  //message MyInt32 { 720  //  // value must be in list [1, 2, 3] 721  //  repeated int32 value = 1 (buf.validate.field).int32 = { in: [1, 2, 3] }; 722  //} 723  //``` 724  repeated int32 in = 6 [(priv.field).cel = { 725    id: "int32.in", 726    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''", 727  }]; 728 729  //`not_in` requires the field value to not be equal to any of the specified 730  // values. If the field value is one of the specified values, an error message 731  // is generated. 732  // 733  //```proto 734  //message MyInt32 { 735  //  // value must not be in list [1, 2, 3] 736  //  repeated int32 value = 1 (buf.validate.field).int32 = { not_in: [1, 2, 3] }; 737  //} 738  //``` 739  repeated int32 not_in = 7 [(priv.field).cel = { 740    id: "int32.not_in", 741    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''", 742  }]; 743} 744 745// Int64Rules describes the constraints applied to `int64` values. These 746// rules may also be applied to the `google.protobuf.Int64Value` Well-Known-Type. 747message Int64Rules { 748  //`const` requires the field value to exactly match the specified value. If 749  // the field value doesn't match, an error message is generated. 750  // 751  //```proto 752  //message MyInt64 { 753  //  // value must equal 42 754  //   int64 value = 1 [(buf.validate.field).int64.const = 42]; 755  //} 756  //``` 757  optional int64 const = 1 [(priv.field).cel = { 758    id: "int64.const", 759    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''", 760  }]; 761 762  //`lt` requires the field value to be less than the specified value (field < 763  // value). If the field value is equal to or greater than the specified value, 764  // an error message is generated. 765  // 766  //```proto 767  //message MyInt64 { 768  //  // value must be less than 10 769  //   int64 value = 1 [(buf.validate.field).int64.lt = 10]; 770  //} 771  //``` 772  optional int64 lt = 2 [(priv.field).cel = { 773    id: "int64.lt", 774    expression: 775      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt" 776      "? 'value must be less than %s'.format([rules.lt]) : ''" 777  }]; 778 779  //`lte` requires the field value to be less than or equal to the specified 780  // value (field <= value). If the field value is greater than the specified 781  // value, an error message is generated. 782  // 783  //```proto 784  //message MyInt64 { 785  //  // value must be less than or equal to 10 786  //   int64 value = 1 [(buf.validate.field).int64.lte = 10]; 787  //} 788  //``` 789  optional int64 lte = 3 [(priv.field).cel = { 790    id: "int64.lte", 791    expression: 792      "!has(rules.gte) && !has(rules.gt) && this > rules.lte" 793      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''" 794  }]; 795 796  //`gt` requires the field value to be greater than the specified value 797  // (exclusive). If the value of `gt` is larger than a specified `lt` or 798  // `lte`, the range is reversed, and the field value must be outside the 799  // specified range. If the field value doesn't meet the required conditions, 800  // an error message is generated. 801  // 802  //```proto 803  //message MyInt64 { 804  //  // value must be greater than 5 [int64.gt] 805  //  int64 value = 1 [(buf.validate.field).int64.gt = 5]; 806  // 807  //  // value must be greater than 5 and less than 10 [int64.gt_lt] 808  //  int64 other_value = 2 [(buf.validate.field).int64 = { gt: 5, lt: 10 }]; 809  // 810  //  // value must be greater than 10 or less than 5 [int64.gt_lt_exclusive] 811  //  int64 another_value = 3 [(buf.validate.field).int64 = { gt: 10, lt: 5 }]; 812  //} 813  //``` 814  optional int64 gt = 4 [ 815    (priv.field).cel = { 816      id: "int64.gt", 817      expression: 818        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt" 819        "? 'value must be greater than %s'.format([rules.gt]) : ''" 820    }, 821    (priv.field).cel = { 822      id: "int64.gt_lt", 823      expression: 824        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)" 825        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''" 826    }, 827    (priv.field).cel = { 828      id: "int64.gt_lt_exclusive", 829      expression: 830        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)" 831        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''" 832    }, 833    (priv.field).cel = { 834      id: "int64.gt_lte", 835      expression: 836        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)" 837        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''" 838    }, 839    (priv.field).cel = { 840      id: "int64.gt_lte_exclusive", 841      expression: 842        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)" 843        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''" 844    } 845  ]; 846 847  //`gte` requires the field value to be greater than or equal to the specified 848  // value (exclusive). If the value of `gte` is larger than a specified `lt` 849  // or `lte`, the range is reversed, and the field value must be outside the 850  // specified range. If the field value doesn't meet the required conditions, 851  // an error message is generated. 852  // 853  //```proto 854  //message MyInt64 { 855  //  // value must be greater than or equal to 5 [int64.gte] 856  //  int64 value = 1 [(buf.validate.field).int64.gte = 5]; 857  // 858  //  // value must be greater than or equal to 5 and less than 10 [int64.gte_lt] 859  //  int64 other_value = 2 [(buf.validate.field).int64 = { gte: 5, lt: 10 }]; 860  // 861  //  // value must be greater than or equal to 10 or less than 5 [int64.gte_lt_exclusive] 862  //  int64 another_value = 3 [(buf.validate.field).int64 = { gte: 10, lt: 5 }]; 863  //} 864  //``` 865  optional int64 gte = 5 [ 866    (priv.field).cel = { 867      id: "int64.gte", 868      expression: 869        "!has(rules.lt) && !has(rules.lte) && this < rules.gte" 870        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''" 871    }, 872    (priv.field).cel = { 873      id: "int64.gte_lt", 874      expression: 875        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)" 876        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''" 877    }, 878    (priv.field).cel = { 879      id: "int64.gte_lt_exclusive", 880      expression: 881        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)" 882        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''" 883    }, 884    (priv.field).cel = { 885      id: "int64.gte_lte", 886      expression: 887        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)" 888        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''" 889    }, 890    (priv.field).cel = { 891      id: "int64.gte_lte_exclusive", 892      expression: 893        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)" 894        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''" 895    } 896  ]; 897 898  //`in` requires the field value to be equal to one of the specified values. 899  // If the field value isn't one of the specified values, an error message is 900  // generated. 901  // 902  //```proto 903  //message MyInt64 { 904  //  // value must be in list [1, 2, 3] 905  //  repeated int64 value = 1 (buf.validate.field).int64 = { in: [1, 2, 3] }; 906  //} 907  //``` 908  repeated int64 in = 6 [(priv.field).cel = { 909    id: "int64.in", 910    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''", 911  }]; 912 913  //`not_in` requires the field value to not be equal to any of the specified 914  // values. If the field value is one of the specified values, an error 915  // message is generated. 916  // 917  //```proto 918  //message MyInt64 { 919  //  // value must not be in list [1, 2, 3] 920  //  repeated int64 value = 1 (buf.validate.field).int64 = { not_in: [1, 2, 3] }; 921  //} 922  //``` 923  repeated int64 not_in = 7 [(priv.field).cel = { 924    id: "int64.not_in", 925    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''", 926  }]; 927} 928 929// UInt32Rules describes the constraints applied to `uint32` values. These 930// rules may also be applied to the `google.protobuf.UInt32Value` Well-Known-Type. 931message UInt32Rules { 932  //`const` requires the field value to exactly match the specified value. If 933  // the field value doesn't match, an error message is generated. 934  // 935  //```proto 936  //message MyUInt32 { 937  //  // value must equal 42 938  //   uint32 value = 1 [(buf.validate.field).uint32.const = 42]; 939  //} 940  //``` 941  optional uint32 const = 1 [(priv.field).cel = { 942    id: "uint32.const", 943    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''", 944  }]; 945 946  //`lt` requires the field value to be less than the specified value (field < 947  // value). If the field value is equal to or greater than the specified value, 948  // an error message is generated. 949  // 950  //```proto 951  //message MyUInt32 { 952  //  // value must be less than 10 953  //   uint32 value = 1 [(buf.validate.field).uint32.lt = 10]; 954  //} 955  //``` 956  optional uint32 lt = 2 [(priv.field).cel = { 957    id: "uint32.lt", 958    expression: 959      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt" 960      "? 'value must be less than %s'.format([rules.lt]) : ''" 961  }]; 962 963  //`lte` requires the field value to be less than or equal to the specified 964  // value (field <= value). If the field value is greater than the specified 965  // value, an error message is generated. 966  // 967  //```proto 968  //message MyUInt32 { 969  //  // value must be less than or equal to 10 970  //   uint32 value = 1 [(buf.validate.field).uint32.lte = 10]; 971  //} 972  //``` 973  optional uint32 lte = 3 [(priv.field).cel = { 974    id: "uint32.lte", 975    expression: 976      "!has(rules.gte) && !has(rules.gt) && this > rules.lte" 977      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''" 978  }]; 979 980  //`gt` requires the field value to be greater than the specified value 981  // (exclusive). If the value of `gt` is larger than a specified `lt` or 982  // `lte`, the range is reversed, and the field value must be outside the 983  // specified range. If the field value doesn't meet the required conditions, 984  // an error message is generated. 985  // 986  //```proto 987  //message MyUInt32 { 988  //  // value must be greater than 5 [uint32.gt] 989  //  uint32 value = 1 [(buf.validate.field).uint32.gt = 5]; 990  // 991  //  // value must be greater than 5 and less than 10 [uint32.gt_lt] 992  //  uint32 other_value = 2 [(buf.validate.field).uint32 = { gt: 5, lt: 10 }]; 993  // 994  //  // value must be greater than 10 or less than 5 [uint32.gt_lt_exclusive] 995  //  uint32 another_value = 3 [(buf.validate.field).uint32 = { gt: 10, lt: 5 }]; 996  //} 997  //``` 998  optional uint32 gt = 4 [ 999    (priv.field).cel = {1000      id: "uint32.gt",1001      expression:1002        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"1003        "? 'value must be greater than %s'.format([rules.gt]) : ''"1004    },1005    (priv.field).cel = {1006      id: "uint32.gt_lt",1007      expression:1008        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"1009        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"1010    },1011    (priv.field).cel = {1012      id: "uint32.gt_lt_exclusive",1013      expression:1014        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"1015        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"1016    },1017    (priv.field).cel = {1018      id: "uint32.gt_lte",1019      expression:1020        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"1021        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1022    },1023    (priv.field).cel = {1024      id: "uint32.gt_lte_exclusive",1025      expression:1026        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"1027        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1028    }1029  ];10301031  //`gte` requires the field value to be greater than or equal to the specified1032  // value (exclusive). If the value of `gte` is larger than a specified `lt`1033  // or `lte`, the range is reversed, and the field value must be outside the1034  // specified range. If the field value doesn't meet the required conditions,1035  // an error message is generated.1036  //1037  //```proto1038  //message MyUInt32 {1039  //  // value must be greater than or equal to 5 [uint32.gte]1040  //  uint32 value = 1 [(buf.validate.field).uint32.gte = 5];1041  //1042  //  // value must be greater than or equal to 5 and less than 10 [uint32.gte_lt]1043  //  uint32 other_value = 2 [(buf.validate.field).uint32 = { gte: 5, lt: 10 }];1044  //1045  //  // value must be greater than or equal to 10 or less than 5 [uint32.gte_lt_exclusive]1046  //  uint32 another_value = 3 [(buf.validate.field).uint32 = { gte: 10, lt: 5 }];1047  //}1048  //```1049  optional uint32 gte = 5 [1050    (priv.field).cel = {1051      id: "uint32.gte",1052      expression:1053        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"1054        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"1055    },1056    (priv.field).cel = {1057      id: "uint32.gte_lt",1058      expression:1059        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"1060        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"1061    },1062    (priv.field).cel = {1063      id: "uint32.gte_lt_exclusive",1064      expression:1065        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"1066        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"1067    },1068    (priv.field).cel = {1069      id: "uint32.gte_lte",1070      expression:1071        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"1072        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1073    },1074    (priv.field).cel = {1075      id: "uint32.gte_lte_exclusive",1076      expression:1077        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"1078        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1079    }1080  ];10811082  //`in` requires the field value to be equal to one of the specified values.1083  // If the field value isn't one of the specified values, an error message is1084  // generated.1085  //1086  //```proto1087  //message MyUInt32 {1088  //  // value must be in list [1, 2, 3]1089  //  repeated uint32 value = 1 (buf.validate.field).uint32 = { in: [1, 2, 3] };1090  //}1091  //```1092  repeated uint32 in = 6 [(priv.field).cel = {1093    id: "uint32.in",1094    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",1095  }];10961097  //`not_in` requires the field value to not be equal to any of the specified1098  // values. If the field value is one of the specified values, an error1099  // message is generated.1100  //1101  //```proto1102  //message MyUInt32 {1103  //  // value must not be in list [1, 2, 3]1104  //  repeated uint32 value = 1 (buf.validate.field).uint32 = { not_in: [1, 2, 3] };1105  //}1106  //```1107  repeated uint32 not_in = 7 [(priv.field).cel = {1108    id: "uint32.not_in",1109    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",1110  }];1111}11121113// UInt64Rules describes the constraints applied to `uint64` values. These1114// rules may also be applied to the `google.protobuf.UInt64Value` Well-Known-Type.1115message UInt64Rules {1116  //`const` requires the field value to exactly match the specified value. If1117  // the field value doesn't match, an error message is generated.1118  //1119  //```proto1120  //message MyUInt64 {1121  //  // value must equal 421122  //   uint64 value = 1 [(buf.validate.field).uint64.const = 42];1123  //}1124  //```1125  optional uint64 const = 1 [(priv.field).cel = {1126    id: "uint64.const",1127    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",1128  }];11291130  //`lt` requires the field value to be less than the specified value (field <1131  // value). If the field value is equal to or greater than the specified value,1132  // an error message is generated.1133  //1134  //```proto1135  //message MyUInt64 {1136  //  // value must be less than 101137  //   uint64 value = 1 [(buf.validate.field).uint64.lt = 10];1138  //}1139  //```1140  optional uint64 lt = 2 [(priv.field).cel = {1141    id: "uint64.lt",1142    expression:1143      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt"1144      "? 'value must be less than %s'.format([rules.lt]) : ''"1145  }];11461147  //`lte` requires the field value to be less than or equal to the specified1148  // value (field <= value). If the field value is greater than the specified1149  // value, an error message is generated.1150  //1151  //```proto1152  //message MyUInt64 {1153  //  // value must be less than or equal to 101154  //   uint64 value = 1 [(buf.validate.field).uint64.lte = 10];1155  //}1156  //```1157  optional uint64 lte = 3 [(priv.field).cel = {1158    id: "uint64.lte",1159    expression:1160      "!has(rules.gte) && !has(rules.gt) && this > rules.lte"1161      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''"1162  }];11631164  //`gt` requires the field value to be greater than the specified value1165  // (exclusive). If the value of `gt` is larger than a specified `lt` or1166  // `lte`, the range is reversed, and the field value must be outside the1167  // specified range. If the field value doesn't meet the required conditions,1168  // an error message is generated.1169  //1170  //```proto1171  //message MyUInt64 {1172  //  // value must be greater than 5 [uint64.gt]1173  //  uint64 value = 1 [(buf.validate.field).uint64.gt = 5];1174  //1175  //  // value must be greater than 5 and less than 10 [uint64.gt_lt]1176  //  uint64 other_value = 2 [(buf.validate.field).uint64 = { gt: 5, lt: 10 }];1177  //1178  //  // value must be greater than 10 or less than 5 [uint64.gt_lt_exclusive]1179  //  uint64 another_value = 3 [(buf.validate.field).uint64 = { gt: 10, lt: 5 }];1180  //}1181  //```1182  optional uint64 gt = 4 [1183    (priv.field).cel = {1184      id: "uint64.gt",1185      expression:1186        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"1187        "? 'value must be greater than %s'.format([rules.gt]) : ''"1188    },1189    (priv.field).cel = {1190      id: "uint64.gt_lt",1191      expression:1192        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"1193        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"1194    },1195    (priv.field).cel = {1196      id: "uint64.gt_lt_exclusive",1197      expression:1198        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"1199        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"1200    },1201    (priv.field).cel = {1202      id: "uint64.gt_lte",1203      expression:1204        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"1205        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1206    },1207    (priv.field).cel = {1208      id: "uint64.gt_lte_exclusive",1209      expression:1210        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"1211        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1212    }1213  ];12141215  //`gte` requires the field value to be greater than or equal to the specified1216  // value (exclusive). If the value of `gte` is larger than a specified `lt`1217  // or `lte`, the range is reversed, and the field value must be outside the1218  // specified range. If the field value doesn't meet the required conditions,1219  // an error message is generated.1220  //1221  //```proto1222  //message MyUInt64 {1223  //  // value must be greater than or equal to 5 [uint64.gte]1224  //  uint64 value = 1 [(buf.validate.field).uint64.gte = 5];1225  //1226  //  // value must be greater than or equal to 5 and less than 10 [uint64.gte_lt]1227  //  uint64 other_value = 2 [(buf.validate.field).uint64 = { gte: 5, lt: 10 }];1228  //1229  //  // value must be greater than or equal to 10 or less than 5 [uint64.gte_lt_exclusive]1230  //  uint64 another_value = 3 [(buf.validate.field).uint64 = { gte: 10, lt: 5 }];1231  //}1232  //```1233  optional uint64 gte = 5 [1234    (priv.field).cel = {1235      id: "uint64.gte",1236      expression:1237        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"1238        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"1239    },1240    (priv.field).cel = {1241      id: "uint64.gte_lt",1242      expression:1243        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"1244        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"1245    },1246    (priv.field).cel = {1247      id: "uint64.gte_lt_exclusive",1248      expression:1249        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"1250        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"1251    },1252    (priv.field).cel = {1253      id: "uint64.gte_lte",1254      expression:1255        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"1256        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1257    },1258    (priv.field).cel = {1259      id: "uint64.gte_lte_exclusive",1260      expression:1261        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"1262        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1263    }1264  ];12651266  //`in` requires the field value to be equal to one of the specified values.1267  // If the field value isn't one of the specified values, an error message is1268  // generated.1269  //1270  //```proto1271  //message MyUInt64 {1272  //  // value must be in list [1, 2, 3]1273  //  repeated uint64 value = 1 (buf.validate.field).uint64 = { in: [1, 2, 3] };1274  //}1275  //```1276  repeated uint64 in = 6 [(priv.field).cel = {1277    id: "uint64.in",1278    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",1279  }];12801281  //`not_in` requires the field value to not be equal to any of the specified1282  // values. If the field value is one of the specified values, an error1283  // message is generated.1284  //1285  //```proto1286  //message MyUInt64 {1287  //  // value must not be in list [1, 2, 3]1288  //  repeated uint64 value = 1 (buf.validate.field).uint64 = { not_in: [1, 2, 3] };1289  //}1290  //```1291  repeated uint64 not_in = 7 [(priv.field).cel = {1292    id: "uint64.not_in",1293    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",1294  }];1295}12961297// SInt32Rules describes the constraints applied to `sint32` values.1298message SInt32Rules {1299  //`const` requires the field value to exactly match the specified value. If1300  // the field value doesn't match, an error message is generated.1301  //1302  //```proto1303  //message MySInt32 {1304  //  // value must equal 421305  //   sint32 value = 1 [(buf.validate.field).sint32.const = 42];1306  //}1307  //```1308  optional sint32 const = 1 [(priv.field).cel = {1309    id: "sint32.const",1310    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",1311  }];13121313  //`lt` requires the field value to be less than the specified value (field1314  // < value). If the field value is equal to or greater than the specified1315  // value, an error message is generated.1316  //1317  //```proto1318  //message MySInt32 {1319  //  // value must be less than 101320  //   sint32 value = 1 [(buf.validate.field).sint32.lt = 10];1321  //}1322  //```1323  optional sint32 lt = 2 [(priv.field).cel = {1324    id: "sint32.lt",1325    expression:1326      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt"1327      "? 'value must be less than %s'.format([rules.lt]) : ''"1328  }];13291330  //`lte` requires the field value to be less than or equal to the specified1331  // value (field <= value). If the field value is greater than the specified1332  // value, an error message is generated.1333  //1334  //```proto1335  //message MySInt32 {1336  //  // value must be less than or equal to 101337  //   sint32 value = 1 [(buf.validate.field).sint32.lte = 10];1338  //}1339  //```1340  optional sint32 lte = 3 [(priv.field).cel = {1341    id: "sint32.lte",1342    expression:1343      "!has(rules.gte) && !has(rules.gt) && this > rules.lte"1344      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''"1345  }];13461347  //`gt` requires the field value to be greater than the specified value1348  // (exclusive). If the value of `gt` is larger than a specified `lt` or1349  // `lte`, the range is reversed, and the field value must be outside the1350  // specified range. If the field value doesn't meet the required conditions,1351  // an error message is generated.1352  //1353  //```proto1354  //message MySInt32 {1355  //  // value must be greater than 5 [sint32.gt]1356  //  sint32 value = 1 [(buf.validate.field).sint32.gt = 5];1357  //1358  //  // value must be greater than 5 and less than 10 [sint32.gt_lt]1359  //  sint32 other_value = 2 [(buf.validate.field).sint32 = { gt: 5, lt: 10 }];1360  //1361  //  // value must be greater than 10 or less than 5 [sint32.gt_lt_exclusive]1362  //  sint32 another_value = 3 [(buf.validate.field).sint32 = { gt: 10, lt: 5 }];1363  //}1364  //```1365  optional sint32 gt = 4 [1366    (priv.field).cel = {1367      id: "sint32.gt",1368      expression:1369        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"1370        "? 'value must be greater than %s'.format([rules.gt]) : ''"1371    },1372    (priv.field).cel = {1373      id: "sint32.gt_lt",1374      expression:1375        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"1376        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"1377    },1378    (priv.field).cel = {1379      id: "sint32.gt_lt_exclusive",1380      expression:1381        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"1382        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"1383    },1384    (priv.field).cel = {1385      id: "sint32.gt_lte",1386      expression:1387        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"1388        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1389    },1390    (priv.field).cel = {1391      id: "sint32.gt_lte_exclusive",1392      expression:1393        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"1394        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1395    }1396  ];13971398  //`gte` requires the field value to be greater than or equal to the specified1399  // value (exclusive). If the value of `gte` is larger than a specified `lt`1400  // or `lte`, the range is reversed, and the field value must be outside the1401  // specified range. If the field value doesn't meet the required conditions,1402  // an error message is generated.1403  //1404  //```proto1405  //message MySInt32 {1406  //  // value must be greater than or equal to 5 [sint32.gte]1407  //  sint32 value = 1 [(buf.validate.field).sint32.gte = 5];1408  //1409  //  // value must be greater than or equal to 5 and less than 10 [sint32.gte_lt]1410  //  sint32 other_value = 2 [(buf.validate.field).sint32 = { gte: 5, lt: 10 }];1411  //1412  //  // value must be greater than or equal to 10 or less than 5 [sint32.gte_lt_exclusive]1413  //  sint32 another_value = 3 [(buf.validate.field).sint32 = { gte: 10, lt: 5 }];1414  //}1415  //```1416  optional sint32 gte = 5 [1417    (priv.field).cel = {1418      id: "sint32.gte",1419      expression:1420        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"1421        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"1422    },1423    (priv.field).cel = {1424      id: "sint32.gte_lt",1425      expression:1426        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"1427        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"1428    },1429    (priv.field).cel = {1430      id: "sint32.gte_lt_exclusive",1431      expression:1432        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"1433        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"1434    },1435    (priv.field).cel = {1436      id: "sint32.gte_lte",1437      expression:1438        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"1439        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1440    },1441    (priv.field).cel = {1442      id: "sint32.gte_lte_exclusive",1443      expression:1444        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"1445        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1446    }1447  ];14481449  //`in` requires the field value to be equal to one of the specified values.1450  // If the field value isn't one of the specified values, an error message is1451  // generated.1452  //1453  //```proto1454  //message MySInt32 {1455  //  // value must be in list [1, 2, 3]1456  //  repeated sint32 value = 1 (buf.validate.field).sint32 = { in: [1, 2, 3] };1457  //}1458  //```1459  repeated sint32 in = 6 [(priv.field).cel = {1460    id: "sint32.in",1461    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",1462  }];14631464  //`not_in` requires the field value to not be equal to any of the specified1465  // values. If the field value is one of the specified values, an error1466  // message is generated.1467  //1468  //```proto1469  //message MySInt32 {1470  //  // value must not be in list [1, 2, 3]1471  //  repeated sint32 value = 1 (buf.validate.field).sint32 = { not_in: [1, 2, 3] };1472  //}1473  //```1474  repeated sint32 not_in = 7 [(priv.field).cel = {1475    id: "sint32.not_in",1476    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",1477  }];1478}14791480// SInt64Rules describes the constraints applied to `sint64` values.1481message SInt64Rules {1482  //`const` requires the field value to exactly match the specified value. If1483  // the field value doesn't match, an error message is generated.1484  //1485  //```proto1486  //message MySInt64 {1487  //  // value must equal 421488  //   sint64 value = 1 [(buf.validate.field).sint64.const = 42];1489  //}1490  //```1491  optional sint64 const = 1 [(priv.field).cel = {1492    id: "sint64.const",1493    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",1494  }];14951496  //`lt` requires the field value to be less than the specified value (field1497  // < value). If the field value is equal to or greater than the specified1498  // value, an error message is generated.1499  //1500  //```proto1501  //message MySInt64 {1502  //  // value must be less than 101503  //   sint64 value = 1 [(buf.validate.field).sint64.lt = 10];1504  //}1505  //```1506  optional sint64 lt = 2 [(priv.field).cel = {1507    id: "sint64.lt",1508    expression:1509      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt"1510      "? 'value must be less than %s'.format([rules.lt]) : ''"1511  }];15121513  //`lte` requires the field value to be less than or equal to the specified1514  // value (field <= value). If the field value is greater than the specified1515  // value, an error message is generated.1516  //1517  //```proto1518  //message MySInt64 {1519  //  // value must be less than or equal to 101520  //   sint64 value = 1 [(buf.validate.field).sint64.lte = 10];1521  //}1522  //```1523  optional sint64 lte = 3 [(priv.field).cel = {1524    id: "sint64.lte",1525    expression:1526      "!has(rules.gte) && !has(rules.gt) && this > rules.lte"1527      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''"1528  }];15291530  //`gt` requires the field value to be greater than the specified value1531  // (exclusive). If the value of `gt` is larger than a specified `lt` or1532  // `lte`, the range is reversed, and the field value must be outside the1533  // specified range. If the field value doesn't meet the required conditions,1534  // an error message is generated.1535  //1536  //```proto1537  //message MySInt64 {1538  //  // value must be greater than 5 [sint64.gt]1539  //  sint64 value = 1 [(buf.validate.field).sint64.gt = 5];1540  //1541  //  // value must be greater than 5 and less than 10 [sint64.gt_lt]1542  //  sint64 other_value = 2 [(buf.validate.field).sint64 = { gt: 5, lt: 10 }];1543  //1544  //  // value must be greater than 10 or less than 5 [sint64.gt_lt_exclusive]1545  //  sint64 another_value = 3 [(buf.validate.field).sint64 = { gt: 10, lt: 5 }];1546  //}1547  //```1548  optional sint64 gt = 4 [1549    (priv.field).cel = {1550      id: "sint64.gt",1551      expression:1552        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"1553        "? 'value must be greater than %s'.format([rules.gt]) : ''"1554    },1555    (priv.field).cel = {1556      id: "sint64.gt_lt",1557      expression:1558        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"1559        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"1560    },1561    (priv.field).cel = {1562      id: "sint64.gt_lt_exclusive",1563      expression:1564        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"1565        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"1566    },1567    (priv.field).cel = {1568      id: "sint64.gt_lte",1569      expression:1570        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"1571        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1572    },1573    (priv.field).cel = {1574      id: "sint64.gt_lte_exclusive",1575      expression:1576        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"1577        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1578    }1579  ];15801581  //`gte` requires the field value to be greater than or equal to the specified1582  // value (exclusive). If the value of `gte` is larger than a specified `lt`1583  // or `lte`, the range is reversed, and the field value must be outside the1584  // specified range. If the field value doesn't meet the required conditions,1585  // an error message is generated.1586  //1587  //```proto1588  //message MySInt64 {1589  //  // value must be greater than or equal to 5 [sint64.gte]1590  //  sint64 value = 1 [(buf.validate.field).sint64.gte = 5];1591  //1592  //  // value must be greater than or equal to 5 and less than 10 [sint64.gte_lt]1593  //  sint64 other_value = 2 [(buf.validate.field).sint64 = { gte: 5, lt: 10 }];1594  //1595  //  // value must be greater than or equal to 10 or less than 5 [sint64.gte_lt_exclusive]1596  //  sint64 another_value = 3 [(buf.validate.field).sint64 = { gte: 10, lt: 5 }];1597  //}1598  //```1599  optional sint64 gte = 5 [1600    (priv.field).cel = {1601      id: "sint64.gte",1602      expression:1603        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"1604        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"1605    },1606    (priv.field).cel = {1607      id: "sint64.gte_lt",1608      expression:1609        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"1610        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"1611    },1612    (priv.field).cel = {1613      id: "sint64.gte_lt_exclusive",1614      expression:1615        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"1616        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"1617    },1618    (priv.field).cel = {1619      id: "sint64.gte_lte",1620      expression:1621        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"1622        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1623    },1624    (priv.field).cel = {1625      id: "sint64.gte_lte_exclusive",1626      expression:1627        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"1628        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1629    }1630  ];16311632  //`in` requires the field value to be equal to one of the specified values.1633  // If the field value isn't one of the specified values, an error message1634  // is generated.1635  //1636  //```proto1637  //message MySInt64 {1638  //  // value must be in list [1, 2, 3]1639  //  repeated sint64 value = 1 (buf.validate.field).sint64 = { in: [1, 2, 3] };1640  //}1641  //```1642  repeated sint64 in = 6 [(priv.field).cel = {1643    id: "sint64.in",1644    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",1645  }];16461647  //`not_in` requires the field value to not be equal to any of the specified1648  // values. If the field value is one of the specified values, an error1649  // message is generated.1650  //1651  //```proto1652  //message MySInt64 {1653  //  // value must not be in list [1, 2, 3]1654  //  repeated sint64 value = 1 (buf.validate.field).sint64 = { not_in: [1, 2, 3] };1655  //}1656  //```1657  repeated sint64 not_in = 7 [(priv.field).cel = {1658    id: "sint64.not_in",1659    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",1660  }];1661}16621663// Fixed32Rules describes the constraints applied to `fixed32` values.1664message Fixed32Rules {1665  //`const` requires the field value to exactly match the specified value.1666  // If the field value doesn't match, an error message is generated.1667  //1668  //```proto1669  //message MyFixed32 {1670  //  // value must equal 421671  //   fixed32 value = 1 [(buf.validate.field).fixed32.const = 42];1672  //}1673  //```1674  optional fixed32 const = 1 [(priv.field).cel = {1675    id: "fixed32.const",1676    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",1677  }];16781679  //`lt` requires the field value to be less than the specified value (field <1680  // value). If the field value is equal to or greater than the specified value,1681  // an error message is generated.1682  //1683  //```proto1684  //message MyFixed32 {1685  //  // value must be less than 101686  //   fixed32 value = 1 [(buf.validate.field).fixed32.lt = 10];1687  //}1688  //```1689  optional fixed32 lt = 2 [(priv.field).cel = {1690    id: "fixed32.lt",1691    expression:1692      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt"1693      "? 'value must be less than %s'.format([rules.lt]) : ''"1694  }];16951696  //`lte` requires the field value to be less than or equal to the specified1697  // value (field <= value). If the field value is greater than the specified1698  // value, an error message is generated.1699  //1700  //```proto1701  //message MyFixed32 {1702  //  // value must be less than or equal to 101703  //   fixed32 value = 1 [(buf.validate.field).fixed32.lte = 10];1704  //}1705  //```1706  optional fixed32 lte = 3 [(priv.field).cel = {1707    id: "fixed32.lte",1708    expression:1709      "!has(rules.gte) && !has(rules.gt) && this > rules.lte"1710      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''"1711  }];17121713  //`gt` requires the field value to be greater than the specified value1714  // (exclusive). If the value of `gt` is larger than a specified `lt` or1715  // `lte`, the range is reversed, and the field value must be outside the1716  // specified range. If the field value doesn't meet the required conditions,1717  // an error message is generated.1718  //1719  //```proto1720  //message MyFixed32 {1721  //  // value must be greater than 5 [fixed32.gt]1722  //  fixed32 value = 1 [(buf.validate.field).fixed32.gt = 5];1723  //1724  //  // value must be greater than 5 and less than 10 [fixed32.gt_lt]1725  //  fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gt: 5, lt: 10 }];1726  //1727  //  // value must be greater than 10 or less than 5 [fixed32.gt_lt_exclusive]1728  //  fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gt: 10, lt: 5 }];1729  //}1730  //```1731  optional fixed32 gt = 4 [1732    (priv.field).cel = {1733      id: "fixed32.gt",1734      expression:1735        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"1736        "? 'value must be greater than %s'.format([rules.gt]) : ''"1737    },1738    (priv.field).cel = {1739      id: "fixed32.gt_lt",1740      expression:1741        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"1742        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"1743    },1744    (priv.field).cel = {1745      id: "fixed32.gt_lt_exclusive",1746      expression:1747        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"1748        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"1749    },1750    (priv.field).cel = {1751      id: "fixed32.gt_lte",1752      expression:1753        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"1754        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1755    },1756    (priv.field).cel = {1757      id: "fixed32.gt_lte_exclusive",1758      expression:1759        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"1760        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1761    }1762  ];17631764  //`gte` requires the field value to be greater than or equal to the specified1765  // value (exclusive). If the value of `gte` is larger than a specified `lt`1766  // or `lte`, the range is reversed, and the field value must be outside the1767  // specified range. If the field value doesn't meet the required conditions,1768  // an error message is generated.1769  //1770  //```proto1771  //message MyFixed32 {1772  //  // value must be greater than or equal to 5 [fixed32.gte]1773  //  fixed32 value = 1 [(buf.validate.field).fixed32.gte = 5];1774  //1775  //  // value must be greater than or equal to 5 and less than 10 [fixed32.gte_lt]1776  //  fixed32 other_value = 2 [(buf.validate.field).fixed32 = { gte: 5, lt: 10 }];1777  //1778  //  // value must be greater than or equal to 10 or less than 5 [fixed32.gte_lt_exclusive]1779  //  fixed32 another_value = 3 [(buf.validate.field).fixed32 = { gte: 10, lt: 5 }];1780  //}1781  //```1782  optional fixed32 gte = 5 [1783    (priv.field).cel = {1784      id: "fixed32.gte",1785      expression:1786        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"1787        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"1788    },1789    (priv.field).cel = {1790      id: "fixed32.gte_lt",1791      expression:1792        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"1793        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"1794    },1795    (priv.field).cel = {1796      id: "fixed32.gte_lt_exclusive",1797      expression:1798        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"1799        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"1800    },1801    (priv.field).cel = {1802      id: "fixed32.gte_lte",1803      expression:1804        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"1805        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1806    },1807    (priv.field).cel = {1808      id: "fixed32.gte_lte_exclusive",1809      expression:1810        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"1811        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1812    }1813  ];18141815  //`in` requires the field value to be equal to one of the specified values.1816  // If the field value isn't one of the specified values, an error message1817  // is generated.1818  //1819  //```proto1820  //message MyFixed32 {1821  //  // value must be in list [1, 2, 3]1822  //  repeated fixed32 value = 1 (buf.validate.field).fixed32 = { in: [1, 2, 3] };1823  //}1824  //```1825  repeated fixed32 in = 6 [(priv.field).cel = {1826    id: "fixed32.in",1827    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",1828  }];18291830  //`not_in` requires the field value to not be equal to any of the specified1831  // values. If the field value is one of the specified values, an error1832  // message is generated.1833  //1834  //```proto1835  //message MyFixed32 {1836  //  // value must not be in list [1, 2, 3]1837  //  repeated fixed32 value = 1 (buf.validate.field).fixed32 = { not_in: [1, 2, 3] };1838  //}1839  //```1840  repeated fixed32 not_in = 7 [(priv.field).cel = {1841    id: "fixed32.not_in",1842    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",1843  }];1844}18451846// Fixed64Rules describes the constraints applied to `fixed64` values.1847message Fixed64Rules {1848  //`const` requires the field value to exactly match the specified value. If1849  // the field value doesn't match, an error message is generated.1850  //1851  //```proto1852  //message MyFixed64 {1853  //  // value must equal 421854  //   fixed64 value = 1 [(buf.validate.field).fixed64.const = 42];1855  //}1856  //```1857  optional fixed64 const = 1 [(priv.field).cel = {1858    id: "fixed64.const",1859    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",1860  }];18611862  //`lt` requires the field value to be less than the specified value (field <1863  // value). If the field value is equal to or greater than the specified value,1864  // an error message is generated.1865  //1866  //```proto1867  //message MyFixed64 {1868  //  // value must be less than 101869  //   fixed64 value = 1 [(buf.validate.field).fixed64.lt = 10];1870  //}1871  //```1872  optional fixed64 lt = 2 [(priv.field).cel = {1873    id: "fixed64.lt",1874    expression:1875      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt"1876      "? 'value must be less than %s'.format([rules.lt]) : ''"1877  }];18781879  //`lte` requires the field value to be less than or equal to the specified1880  // value (field <= value). If the field value is greater than the specified1881  // value, an error message is generated.1882  //1883  //```proto1884  //message MyFixed64 {1885  //  // value must be less than or equal to 101886  //   fixed64 value = 1 [(buf.validate.field).fixed64.lte = 10];1887  //}1888  //```1889  optional fixed64 lte = 3 [(priv.field).cel = {1890    id: "fixed64.lte",1891    expression:1892      "!has(rules.gte) && !has(rules.gt) && this > rules.lte"1893      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''"1894  }];18951896  //`gt` requires the field value to be greater than the specified value1897  // (exclusive). If the value of `gt` is larger than a specified `lt` or1898  // `lte`, the range is reversed, and the field value must be outside the1899  // specified range. If the field value doesn't meet the required conditions,1900  // an error message is generated.1901  //1902  //```proto1903  //message MyFixed64 {1904  //  // value must be greater than 5 [fixed64.gt]1905  //  fixed64 value = 1 [(buf.validate.field).fixed64.gt = 5];1906  //1907  //  // value must be greater than 5 and less than 10 [fixed64.gt_lt]1908  //  fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gt: 5, lt: 10 }];1909  //1910  //  // value must be greater than 10 or less than 5 [fixed64.gt_lt_exclusive]1911  //  fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gt: 10, lt: 5 }];1912  //}1913  //```1914  optional fixed64 gt = 4 [1915    (priv.field).cel = {1916      id: "fixed64.gt",1917      expression:1918        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"1919        "? 'value must be greater than %s'.format([rules.gt]) : ''"1920    },1921    (priv.field).cel = {1922      id: "fixed64.gt_lt",1923      expression:1924        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"1925        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"1926    },1927    (priv.field).cel = {1928      id: "fixed64.gt_lt_exclusive",1929      expression:1930        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"1931        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"1932    },1933    (priv.field).cel = {1934      id: "fixed64.gt_lte",1935      expression:1936        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"1937        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1938    },1939    (priv.field).cel = {1940      id: "fixed64.gt_lte_exclusive",1941      expression:1942        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"1943        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"1944    }1945  ];19461947  //`gte` requires the field value to be greater than or equal to the specified1948  // value (exclusive). If the value of `gte` is larger than a specified `lt`1949  // or `lte`, the range is reversed, and the field value must be outside the1950  // specified range. If the field value doesn't meet the required conditions,1951  // an error message is generated.1952  //1953  //```proto1954  //message MyFixed64 {1955  //  // value must be greater than or equal to 5 [fixed64.gte]1956  //  fixed64 value = 1 [(buf.validate.field).fixed64.gte = 5];1957  //1958  //  // value must be greater than or equal to 5 and less than 10 [fixed64.gte_lt]1959  //  fixed64 other_value = 2 [(buf.validate.field).fixed64 = { gte: 5, lt: 10 }];1960  //1961  //  // value must be greater than or equal to 10 or less than 5 [fixed64.gte_lt_exclusive]1962  //  fixed64 another_value = 3 [(buf.validate.field).fixed64 = { gte: 10, lt: 5 }];1963  //}1964  //```1965  optional fixed64 gte = 5 [1966    (priv.field).cel = {1967      id: "fixed64.gte",1968      expression:1969        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"1970        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"1971    },1972    (priv.field).cel = {1973      id: "fixed64.gte_lt",1974      expression:1975        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"1976        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"1977    },1978    (priv.field).cel = {1979      id: "fixed64.gte_lt_exclusive",1980      expression:1981        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"1982        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"1983    },1984    (priv.field).cel = {1985      id: "fixed64.gte_lte",1986      expression:1987        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"1988        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1989    },1990    (priv.field).cel = {1991      id: "fixed64.gte_lte_exclusive",1992      expression:1993        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"1994        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"1995    }1996  ];19971998  //`in` requires the field value to be equal to one of the specified values.1999  // If the field value isn't one of the specified values, an error message is2000  // generated.2001  //2002  //```proto2003  //message MyFixed64 {2004  //  // value must be in list [1, 2, 3]2005  //  repeated fixed64 value = 1 (buf.validate.field).fixed64 = { in: [1, 2, 3] };2006  //}2007  //```2008  repeated fixed64 in = 6 [(priv.field).cel = {2009    id: "fixed64.in",2010    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",2011  }];20122013  //`not_in` requires the field value to not be equal to any of the specified2014  // values. If the field value is one of the specified values, an error2015  // message is generated.2016  //2017  //```proto2018  //message MyFixed64 {2019  //  // value must not be in list [1, 2, 3]2020  //  repeated fixed64 value = 1 (buf.validate.field).fixed64 = { not_in: [1, 2, 3] };2021  //}2022  //```2023  repeated fixed64 not_in = 7 [(priv.field).cel = {2024    id: "fixed64.not_in",2025    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",2026  }];2027}20282029// SFixed32Rules describes the constraints applied to `fixed32` values.2030message SFixed32Rules {2031  //`const` requires the field value to exactly match the specified value. If2032  // the field value doesn't match, an error message is generated.2033  //2034  //```proto2035  //message MySFixed32 {2036  //  // value must equal 422037  //   sfixed32 value = 1 [(buf.validate.field).sfixed32.const = 42];2038  //}2039  //```2040  optional sfixed32 const = 1 [(priv.field).cel = {2041    id: "sfixed32.const",2042    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",2043  }];20442045  //`lt` requires the field value to be less than the specified value (field <2046  // value). If the field value is equal to or greater than the specified value,2047  // an error message is generated.2048  //2049  //```proto2050  //message MySFixed32 {2051  //  // value must be less than 102052  //   sfixed32 value = 1 [(buf.validate.field).sfixed32.lt = 10];2053  //}2054  //```2055  optional sfixed32 lt = 2 [(priv.field).cel = {2056    id: "sfixed32.lt",2057    expression:2058      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt"2059      "? 'value must be less than %s'.format([rules.lt]) : ''"2060  }];20612062  //`lte` requires the field value to be less than or equal to the specified2063  // value (field <= value). If the field value is greater than the specified2064  // value, an error message is generated.2065  //2066  //```proto2067  //message MySFixed32 {2068  //  // value must be less than or equal to 102069  //   sfixed32 value = 1 [(buf.validate.field).sfixed32.lte = 10];2070  //}2071  //```2072  optional sfixed32 lte = 3 [(priv.field).cel = {2073    id: "sfixed32.lte",2074    expression:2075      "!has(rules.gte) && !has(rules.gt) && this > rules.lte"2076      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''"2077  }];20782079  //`gt` requires the field value to be greater than the specified value2080  // (exclusive). If the value of `gt` is larger than a specified `lt` or2081  // `lte`, the range is reversed, and the field value must be outside the2082  // specified range. If the field value doesn't meet the required conditions,2083  // an error message is generated.2084  //2085  //```proto2086  //message MySFixed32 {2087  //  // value must be greater than 5 [sfixed32.gt]2088  //  sfixed32 value = 1 [(buf.validate.field).sfixed32.gt = 5];2089  //2090  //  // value must be greater than 5 and less than 10 [sfixed32.gt_lt]2091  //  sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gt: 5, lt: 10 }];2092  //2093  //  // value must be greater than 10 or less than 5 [sfixed32.gt_lt_exclusive]2094  //  sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gt: 10, lt: 5 }];2095  //}2096  //```2097  optional sfixed32 gt = 4 [2098    (priv.field).cel = {2099      id: "sfixed32.gt",2100      expression:2101        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"2102        "? 'value must be greater than %s'.format([rules.gt]) : ''"2103    },2104    (priv.field).cel = {2105      id: "sfixed32.gt_lt",2106      expression:2107        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"2108        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"2109    },2110    (priv.field).cel = {2111      id: "sfixed32.gt_lt_exclusive",2112      expression:2113        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"2114        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"2115    },2116    (priv.field).cel = {2117      id: "sfixed32.gt_lte",2118      expression:2119        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"2120        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"2121    },2122    (priv.field).cel = {2123      id: "sfixed32.gt_lte_exclusive",2124      expression:2125        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"2126        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"2127    }2128  ];21292130  //`gte` requires the field value to be greater than or equal to the specified2131  // value (exclusive). If the value of `gte` is larger than a specified `lt`2132  // or `lte`, the range is reversed, and the field value must be outside the2133  // specified range. If the field value doesn't meet the required conditions,2134  // an error message is generated.2135  //2136  //```proto2137  //message MySFixed32 {2138  //  // value must be greater than or equal to 5 [sfixed32.gte]2139  //  sfixed32 value = 1 [(buf.validate.field).sfixed32.gte = 5];2140  //2141  //  // value must be greater than or equal to 5 and less than 10 [sfixed32.gte_lt]2142  //  sfixed32 other_value = 2 [(buf.validate.field).sfixed32 = { gte: 5, lt: 10 }];2143  //2144  //  // value must be greater than or equal to 10 or less than 5 [sfixed32.gte_lt_exclusive]2145  //  sfixed32 another_value = 3 [(buf.validate.field).sfixed32 = { gte: 10, lt: 5 }];2146  //}2147  //```2148  optional sfixed32 gte = 5 [2149    (priv.field).cel = {2150      id: "sfixed32.gte",2151      expression:2152        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"2153        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"2154    },2155    (priv.field).cel = {2156      id: "sfixed32.gte_lt",2157      expression:2158        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"2159        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"2160    },2161    (priv.field).cel = {2162      id: "sfixed32.gte_lt_exclusive",2163      expression:2164        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"2165        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"2166    },2167    (priv.field).cel = {2168      id: "sfixed32.gte_lte",2169      expression:2170        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"2171        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"2172    },2173    (priv.field).cel = {2174      id: "sfixed32.gte_lte_exclusive",2175      expression:2176        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"2177        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"2178    }2179  ];21802181  //`in` requires the field value to be equal to one of the specified values.2182  // If the field value isn't one of the specified values, an error message is2183  // generated.2184  //2185  //```proto2186  //message MySFixed32 {2187  //  // value must be in list [1, 2, 3]2188  //  repeated sfixed32 value = 1 (buf.validate.field).sfixed32 = { in: [1, 2, 3] };2189  //}2190  //```2191  repeated sfixed32 in = 6 [(priv.field).cel = {2192    id: "sfixed32.in",2193    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",2194  }];21952196  //`not_in` requires the field value to not be equal to any of the specified2197  // values. If the field value is one of the specified values, an error2198  // message is generated.2199  //2200  //```proto2201  //message MySFixed32 {2202  //  // value must not be in list [1, 2, 3]2203  //  repeated sfixed32 value = 1 (buf.validate.field).sfixed32 = { not_in: [1, 2, 3] };2204  //}2205  //```2206  repeated sfixed32 not_in = 7 [(priv.field).cel = {2207    id: "sfixed32.not_in",2208    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",2209  }];2210}22112212// SFixed64Rules describes the constraints applied to `fixed64` values.2213message SFixed64Rules {2214  //`const` requires the field value to exactly match the specified value. If2215  // the field value doesn't match, an error message is generated.2216  //2217  //```proto2218  //message MySFixed64 {2219  //  // value must equal 422220  //   sfixed64 value = 1 [(buf.validate.field).sfixed64.const = 42];2221  //}2222  //```2223  optional sfixed64 const = 1 [(priv.field).cel = {2224    id: "sfixed64.const",2225    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",2226  }];22272228  //`lt` requires the field value to be less than the specified value (field <2229  // value). If the field value is equal to or greater than the specified value,2230  // an error message is generated.2231  //2232  //```proto2233  //message MySFixed64 {2234  //  // value must be less than 102235  //   sfixed64 value = 1 [(buf.validate.field).sfixed64.lt = 10];2236  //}2237  //```2238  optional sfixed64 lt = 2 [(priv.field).cel = {2239    id: "sfixed64.lt",2240    expression:2241      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt"2242      "? 'value must be less than %s'.format([rules.lt]) : ''"2243  }];22442245  //`lte` requires the field value to be less than or equal to the specified2246  // value (field <= value). If the field value is greater than the specified2247  // value, an error message is generated.2248  //2249  //```proto2250  //message MySFixed64 {2251  //  // value must be less than or equal to 102252  //   sfixed64 value = 1 [(buf.validate.field).sfixed64.lte = 10];2253  //}2254  //```2255  optional sfixed64 lte = 3 [(priv.field).cel = {2256    id: "sfixed64.lte",2257    expression:2258      "!has(rules.gte) && !has(rules.gt) && this > rules.lte"2259      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''"2260  }];22612262  //`gt` requires the field value to be greater than the specified value2263  // (exclusive). If the value of `gt` is larger than a specified `lt` or2264  // `lte`, the range is reversed, and the field value must be outside the2265  // specified range. If the field value doesn't meet the required conditions,2266  // an error message is generated.2267  //2268  //```proto2269  //message MySFixed64 {2270  //  // value must be greater than 5 [sfixed64.gt]2271  //  sfixed64 value = 1 [(buf.validate.field).sfixed64.gt = 5];2272  //2273  //  // value must be greater than 5 and less than 10 [sfixed64.gt_lt]2274  //  sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gt: 5, lt: 10 }];2275  //2276  //  // value must be greater than 10 or less than 5 [sfixed64.gt_lt_exclusive]2277  //  sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gt: 10, lt: 5 }];2278  //}2279  //```2280  optional sfixed64 gt = 4 [2281    (priv.field).cel = {2282      id: "sfixed64.gt",2283      expression:2284        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"2285        "? 'value must be greater than %s'.format([rules.gt]) : ''"2286    },2287    (priv.field).cel = {2288      id: "sfixed64.gt_lt",2289      expression:2290        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"2291        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"2292    },2293    (priv.field).cel = {2294      id: "sfixed64.gt_lt_exclusive",2295      expression:2296        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"2297        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"2298    },2299    (priv.field).cel = {2300      id: "sfixed64.gt_lte",2301      expression:2302        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"2303        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"2304    },2305    (priv.field).cel = {2306      id: "sfixed64.gt_lte_exclusive",2307      expression:2308        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"2309        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"2310    }2311  ];23122313  //`gte` requires the field value to be greater than or equal to the specified2314  // value (exclusive). If the value of `gte` is larger than a specified `lt`2315  // or `lte`, the range is reversed, and the field value must be outside the2316  // specified range. If the field value doesn't meet the required conditions,2317  // an error message is generated.2318  //2319  //```proto2320  //message MySFixed64 {2321  //  // value must be greater than or equal to 5 [sfixed64.gte]2322  //  sfixed64 value = 1 [(buf.validate.field).sfixed64.gte = 5];2323  //2324  //  // value must be greater than or equal to 5 and less than 10 [sfixed64.gte_lt]2325  //  sfixed64 other_value = 2 [(buf.validate.field).sfixed64 = { gte: 5, lt: 10 }];2326  //2327  //  // value must be greater than or equal to 10 or less than 5 [sfixed64.gte_lt_exclusive]2328  //  sfixed64 another_value = 3 [(buf.validate.field).sfixed64 = { gte: 10, lt: 5 }];2329  //}2330  //```2331  optional sfixed64 gte = 5 [2332    (priv.field).cel = {2333      id: "sfixed64.gte",2334      expression:2335        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"2336        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"2337    },2338    (priv.field).cel = {2339      id: "sfixed64.gte_lt",2340      expression:2341        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"2342        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"2343    },2344    (priv.field).cel = {2345      id: "sfixed64.gte_lt_exclusive",2346      expression:2347        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"2348        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"2349    },2350    (priv.field).cel = {2351      id: "sfixed64.gte_lte",2352      expression:2353        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"2354        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"2355    },2356    (priv.field).cel = {2357      id: "sfixed64.gte_lte_exclusive",2358      expression:2359        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"2360        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"2361    }2362  ];23632364  //`in` requires the field value to be equal to one of the specified values.2365  // If the field value isn't one of the specified values, an error message is2366  // generated.2367  //2368  //```proto2369  //message MySFixed64 {2370  //  // value must be in list [1, 2, 3]2371  //  repeated sfixed64 value = 1 (buf.validate.field).sfixed64 = { in: [1, 2, 3] };2372  //}2373  //```2374  repeated sfixed64 in = 6 [(priv.field).cel = {2375    id: "sfixed64.in",2376    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",2377  }];23782379  //`not_in` requires the field value to not be equal to any of the specified2380  // values. If the field value is one of the specified values, an error2381  // message is generated.2382  //2383  //```proto2384  //message MySFixed64 {2385  //  // value must not be in list [1, 2, 3]2386  //  repeated sfixed64 value = 1 (buf.validate.field).sfixed64 = { not_in: [1, 2, 3] };2387  //}2388  //```2389  repeated sfixed64 not_in = 7 [(priv.field).cel = {2390    id: "sfixed64.not_in",2391    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",2392  }];2393}23942395// BoolRules describes the constraints applied to `bool` values. These rules2396// may also be applied to the `google.protobuf.BoolValue` Well-Known-Type.2397message BoolRules {2398  //`const` requires the field value to exactly match the specified boolean value.2399  //If the field value doesn't match, an error message is generated.2400  //2401  //```proto2402  //message MyBool {2403  //  // value must equal true2404  //   bool value = 1 [(buf.validate.field).bool.const = true];2405  //}2406  //```2407  optional bool const = 1 [(priv.field).cel = {2408    id: "bool.const",2409    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",2410  }];2411}24122413// StringRules describes the constraints applied to `string` values These2414// rules may also be applied to the `google.protobuf.StringValue` Well-Known-Type.2415message StringRules {2416  //`const` requires the field value to exactly match the specified value. If2417  //the field value doesn't match, an error message is generated.2418  //2419  //```proto2420  //message MyString {2421  //  // value must equal `hello`2422  //   string value = 1 [(buf.validate.field).string.const = "hello"];2423  //}2424  //```2425  optional string const = 1 [(priv.field).cel = {2426    id: "string.const",2427    expression: "this != rules.const ? 'value must equal `%s`'.format([rules.const]) : ''"2428  }];24292430  //`len` dictates that the field value must have the specified2431  //number of characters (Unicode code points), which may differ from the number2432  //of bytes in the string. If the field value does not meet the specified2433  //length, an error message will be generated.2434  //2435  //```proto2436  //message MyString {2437  //  // value must equal 5 runes2438  //   string value = 1 [(buf.validate.field).string.len = 5];2439  //}2440  //```2441  optional uint64 len = 19 [(priv.field).cel = {2442    id: "string.len",2443    expression: "uint(this.size()) != rules.len ? 'value must equal %s runes'.format([rules.len]) : ''"2444  }];24452446  //`min_len` specifies that the field value must have at least the specified2447  //number of characters (Unicode code points), which may differ from the number2448  //of bytes in the string. If the field value contains fewer characters, an error2449  //message will be generated.2450  //2451  //```proto2452  //message MyString {2453  //  // value length must be at least 3 runes2454  //   string value = 1 [(buf.validate.field).string.min_len = 3];2455  //}2456  //```2457  optional uint64 min_len = 2 [(priv.field).cel = {2458    id: "string.min_len",2459    expression: "uint(this.size()) < rules.min_len ? 'value length must be at least %s runes'.format([rules.min_len]) : ''"2460  }];24612462  //`max_len` specifies that the field value must have no more than the specified2463  //number of characters (Unicode code points), which may differ from the2464  //number of bytes in the string. If the field value contains more characters,2465  //an error message will be generated.2466  //2467  //```proto2468  //message MyString {2469  //  // value length must be at most 10 runes2470  //   string value = 1 [(buf.validate.field).string.max_len = 10];2471  //}2472  //```2473  optional uint64 max_len = 3 [(priv.field).cel = {2474    id: "string.max_len",2475    expression: "uint(this.size()) > rules.max_len ? 'value length must be at most %s runes'.format([rules.max_len]) : ''"2476  }];24772478  //`len_bytes` dictates that the field value must have the specified number of2479  //bytes. If the field value does not match the specified length in bytes,2480  //an error message will be generated.2481  //2482  //```proto2483  //message MyString {2484  //  // value length must be 6 bytes2485  //   string value = 1 [(buf.validate.field).string.len_bytes = 6];2486  //}2487  //```2488  optional uint64 len_bytes = 20 [(priv.field).cel = {2489    id: "string.len_bytes",2490    expression: "uint(bytes(this).size()) != rules.len_bytes ? 'value length must be %s bytes'.format([rules.len_bytes]) : ''"2491  }];24922493  //`min_bytes` specifies that the field value must have at least the specified2494  //number of bytes. If the field value contains fewer bytes, an error message2495  //will be generated.2496  //2497  //```proto2498  //message MyString {2499  //  // value length must be at least 4 bytes2500  //   string value = 1 [(buf.validate.field).string.min_bytes = 4];2501  //}2502  //2503  //```2504  optional uint64 min_bytes = 4 [(priv.field).cel = {2505    id: "string.min_bytes",2506    expression: "uint(bytes(this).size()) < rules.min_bytes ? 'value length must be at least %s bytes'.format([rules.min_bytes]) : ''"2507  }];25082509  //`max_bytes` specifies that the field value must have no more than the2510  //specified number of bytes. If the field value contains more bytes, an2511  //error message will be generated.2512  //2513  //```proto2514  //message MyString {2515  //  // value length must be at most 8 bytes2516  //   string value = 1 [(buf.validate.field).string.max_bytes = 8];2517  //}2518  //```2519  optional uint64 max_bytes = 5 [(priv.field).cel = {2520    id: "string.max_bytes",2521    expression: "uint(bytes(this).size()) > rules.max_bytes ? 'value length must be at most %s bytes'.format([rules.max_bytes]) : ''",2522  }];25232524  //`pattern` specifies that the field value must match the specified2525  //regular expression (RE2 syntax), with the expression provided without any2526  //delimiters. If the field value doesn't match the regular expression, an2527  //error message will be generated.2528  //2529  //```proto2530  //message MyString {2531  //  // value does not match regex pattern `^[a-zA-Z]//$`2532  //   string value = 1 [(buf.validate.field).string.pattern = "^[a-zA-Z]//$"];2533  //}2534  //```2535  optional string pattern = 6 [(priv.field).cel = {2536    id: "string.pattern",2537    expression: "!this.matches(rules.pattern) ? 'value does not match regex pattern `%s`'.format([rules.pattern]) : ''"2538  }];25392540  //`prefix` specifies that the field value must have the2541  //specified substring at the beginning of the string. If the field value2542  //doesn't start with the specified prefix, an error message will be2543  //generated.2544  //2545  //```proto2546  //message MyString {2547  //  // value does not have prefix `pre`2548  //   string value = 1 [(buf.validate.field).string.prefix = "pre"];2549  //}2550  //```2551  optional string prefix = 7 [(priv.field).cel = {2552    id: "string.prefix",2553    expression: "!this.startsWith(rules.prefix) ? 'value does not have prefix `%s`'.format([rules.prefix]) : ''"2554  }];25552556  //`suffix` specifies that the field value must have the2557  //specified substring at the end of the string. If the field value doesn't2558  //end with the specified suffix, an error message will be generated.2559  //2560  //```proto2561  //message MyString {2562  //  // value does not have suffix `post`2563  //   string value = 1 [(buf.validate.field).string.suffix = "post"];2564  //}2565  //```2566  optional string suffix = 8 [(priv.field).cel = {2567    id: "string.suffix",2568    expression: "!this.endsWith(rules.suffix) ? 'value does not have suffix `%s`'.format([rules.suffix]) : ''"2569  }];25702571  //`contains` specifies that the field value must have the2572  //specified substring anywhere in the string. If the field value doesn't2573  //contain the specified substring, an error message will be generated.2574  //2575  //```proto2576  //message MyString {2577  //  // value does not contain substring `inside`.2578  //   string value = 1 [(buf.validate.field).string.contains = "inside"];2579  //}2580  //```2581  optional string contains = 9 [(priv.field).cel = {2582    id: "string.contains",2583    expression: "!this.contains(rules.contains) ? 'value does not contain substring `%s`'.format([rules.contains]) : ''"2584  }];25852586  //`not_contains` specifies that the field value must not have the2587  //specified substring anywhere in the string. If the field value contains2588  //the specified substring, an error message will be generated.2589  //2590  //```proto2591  //message MyString {2592  //  // value contains substring `inside`.2593  //   string value = 1 [(buf.validate.field).string.not_contains = "inside"];2594  //}2595  //```2596  optional string not_contains = 23 [(priv.field).cel = {2597    id: "string.not_contains",2598    expression: "this.contains(rules.not_contains) ? 'value contains substring `%s`'.format([rules.not_contains]) : ''"2599  }];26002601  //`in` specifies that the field value must be equal to one of the specified2602  //values. If the field value isn't one of the specified values, an error2603  //message will be generated.2604  //2605  //```proto2606  //message MyString {2607  //  // value must be in list ["apple", "banana"]2608  //  repeated string value = 1 [(buf.validate.field).string.in = "apple", (buf.validate.field).string.in = "banana"];2609  //}2610  //```2611  repeated string in = 10 [(priv.field).cel = {2612    id: "string.in",2613    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''"2614  }];26152616  //`not_in` specifies that the field value cannot be equal to any2617  //of the specified values. If the field value is one of the specified values,2618  //an error message will be generated.2619  //```proto2620  //message MyString {2621  //  // value must not be in list ["orange", "grape"]2622  //  repeated string value = 1 [(buf.validate.field).string.not_in = "orange", (buf.validate.field).string.not_in = "grape"];2623  //}2624  //```2625  repeated string not_in = 11 [(priv.field).cel = {2626    id: "string.not_in",2627    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''"2628  }];26292630  // `WellKnown` rules provide advanced constraints against common string2631  // patterns2632  oneof well_known {2633    //`email` specifies that the field value must be a valid email address2634    //(addr-spec only) as defined by [RFC 5322](https://tools.ietf.org/html/rfc5322#section-3.4.1).2635    //If the field value isn't a valid email address, an error message will be generated.2636    //2637    //```proto2638    //message MyString {2639    //  // value must be a valid email address2640    //   string value = 1 [(buf.validate.field).string.email = true];2641    //}2642    //```2643    bool email = 12 [(priv.field).cel = {2644      id: "string.email",2645      message: "value must be a valid email address",2646      expression: "this.isEmail()"2647    }];26482649    //`hostname` specifies that the field value must be a valid2650    //hostname as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5). This constraint doesn't support2651    //internationalized domain names (IDNs). If the field value isn't a2652    //valid hostname, an error message will be generated.2653    //2654    //```proto2655    //message MyString {2656    //  // value must be a valid hostname2657    //   string value = 1 [(buf.validate.field).string.hostname = true];2658    //}2659    //```2660    bool hostname = 13 [(priv.field).cel = {2661      id: "string.hostname",2662      message: "value must be a valid hostname",2663      expression: "this.isHostname()",2664    }];26652666    //`ip` specifies that the field value must be a valid IP2667    //(v4 or v6) address, without surrounding square brackets for IPv6 addresses.2668    //If the field value isn't a valid IP address, an error message will be2669    //generated.2670    //2671    //```proto2672    //message MyString {2673    //  // value must be a valid IP address2674    //   string value = 1 [(buf.validate.field).string.ip = true];2675    //}2676    //```2677    bool ip = 14 [(priv.field).cel = {2678      id: "string.ip",2679      message: "value must be a valid IP address",2680      expression: "this.isIp()",2681    }];26822683    //`ipv4` specifies that the field value must be a valid IPv42684    //address. If the field value isn't a valid IPv4 address, an error message2685    //will be generated.2686    //2687    //```proto2688    //message MyString {2689    //  // value must be a valid IPv4 address2690    //   string value = 1 [(buf.validate.field).string.ipv4 = true];2691    //}2692    //```2693    bool ipv4 = 15 [(priv.field).cel = {2694      id: "string.ipv4",2695      message: "value must be a valid IPv4 address",2696      expression: "this.isIp(4)"2697    }];26982699    //`ipv6` specifies that the field value must be a valid2700    //IPv6 address, without surrounding square brackets. If the field value is2701    //not a valid IPv6 address, an error message will be generated.2702    //2703    //```proto2704    //message MyString {2705    //  // value must be a valid IPv6 address2706    //   string value = 1 [(buf.validate.field).string.ipv6 = true];2707    //}2708    //```2709    bool ipv6 = 16 [(priv.field).cel = {2710      id: "string.ipv6",2711      message: "value must be a valid IPv6 address",2712      expression: "this.isIp(6)",2713    }];27142715    //`uri` specifies that the field value must be a valid,2716    //absolute URI as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3). If the field value isn't a valid,2717    //absolute URI, an error message will be generated.2718    //2719    //```proto2720    //message MyString {2721    //  // value must be a valid URI2722    //   string value = 1 [(buf.validate.field).string.uri = true];2723    //}2724    //```2725    bool uri = 17 [(priv.field).cel = {2726      id: "string.uri",2727      message: "value must be a valid URI",2728      expression: "this.isUri()",2729    }];27302731    //`uri_ref` specifies that the field value must be a valid URI2732    //as defined by [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) and may be either relative or absolute. If the2733    //field value isn't a valid URI, an error message will be generated.2734    //2735    //```proto2736    //message MyString {2737    //  // value must be a valid URI2738    //   string value = 1 [(buf.validate.field).string.uri_ref = true];2739    //}2740    //```2741    bool uri_ref = 18 [(priv.field).cel = {2742      id: "string.uri_ref",2743      message: "value must be a valid URI",2744      expression: "this.isUriRef()",2745    }];27462747    //`address` specifies that the field value must be either a valid hostname2748    //as defined by [RFC 1034](https://tools.ietf.org/html/rfc1034#section-3.5)2749    //(which doesn't support internationalized domain names or IDNs) or a valid2750    //IP (v4 or v6). If the field value isn't a valid hostname or IP, an error2751    //message will be generated.2752    //2753    //```proto2754    //message MyString {2755    //  // value must be a valid hostname, or ip address2756    //   string value = 1 [(buf.validate.field).string.address = true];2757    //}2758    //```2759    bool address = 21 [(priv.field).cel = {2760      id: "string.address",2761      message: "value must be a valid hostname, or ip address",2762      expression: "this.isHostname() || this.isIp()",2763    }];27642765    //`uuid` specifies that the field value must be a valid UUID as defined by2766    //[RFC 4122](https://tools.ietf.org/html/rfc4122#section-4.1.2). If the2767    //field value isn't a valid UUID, an error message will be generated.2768    //2769    //```proto2770    //message MyString {2771    //  // value must be a valid UUID2772    //   string value = 1 [(buf.validate.field).string.uuid = true];2773    //}2774    //```2775    bool uuid = 22 [(priv.field).cel = {2776      id: "string.uuid",2777      expression: "!this.matches('^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$') ? 'value must be a valid UUID' : ''"2778    }];27792780    //`well_known_regex` specifies a common well-known pattern2781    //defined as a regex. If the field value doesn't match the well-known2782    //regex, an error message will be generated.2783    //2784    //```proto2785    //message MyString {2786    //  // value must be a valid HTTP header value2787    //   string value = 1 [(buf.validate.field).string.well_known_regex = 2];2788    //}2789    //```2790    //2791    //#### KnownRegex2792    //2793    //`well_known_regex` contains some well-known patterns.2794    //2795    //| Name                          | Number | Description                               |2796    //|-------------------------------|--------|-------------------------------------------|2797    //| KNOWN_REGEX_UNSPECIFIED       | 0      |                                           |2798    //| KNOWN_REGEX_HTTP_HEADER_NAME  | 1      | HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2)  |2799    //| KNOWN_REGEX_HTTP_HEADER_VALUE | 2      | HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4) |2800    KnownRegex well_known_regex = 24 [2801      (priv.field).cel = {2802        id: "string.well_known_regex.header_name"2803        expression:2804          "rules.well_known_regex == 1 && !this.matches(!has(rules.strict) || rules.strict ?"2805          "'^:?[0-9a-zA-Z!#$%&\\'*+-.^_|~\\x60]+$' :"2806          "'^[^\\u0000\\u000A\\u000D]+$') ? 'value must be a valid HTTP header name' : ''",2807      },2808      (priv.field).cel = {2809        id: "string.well_known_regex.header_value",2810        expression:2811          "rules.well_known_regex == 2 && !this.matches(!has(rules.strict) || rules.strict ?"2812          "'^[^\\u0000-\\u0008\\u000A-\\u001F\\u007F]*$' :"2813          "'^[^\\u0000\\u000A\\u000D]*$') ? 'value must be a valid HTTP header value' : ''",2814      }2815    ];2816  }28172818  //This applies to regexes `HTTP_HEADER_NAME` and `HTTP_HEADER_VALUE` to2819  //enable strict header validation. By default, this is true, and HTTP header2820  //validations are [RFC-compliant](https://tools.ietf.org/html/rfc7230#section-3). Setting to false will enable looser2821  //validations that only disallow `\r\n\0` characters, which can be used to2822  //bypass header matching rules.2823  //2824  //```proto2825  //message MyString {2826  //   // The field `value` must have be a valid HTTP headers, but not enforced with strict rules.2827  //   string value = 1 [(buf.validate.field).string.strict = false];2828  //}2829  //```2830  optional bool strict = 25;2831}28322833// WellKnownRegex contain some well-known patterns.2834enum KnownRegex {2835  KNOWN_REGEX_UNSPECIFIED = 0;28362837  // HTTP header name as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2).2838  KNOWN_REGEX_HTTP_HEADER_NAME = 1;28392840  // HTTP header value as defined by [RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4).2841  KNOWN_REGEX_HTTP_HEADER_VALUE = 2;2842}28432844// BytesRules describe the constraints applied to `bytes` values. These rules2845// may also be applied to the `google.protobuf.BytesValue` Well-Known-Type.2846message BytesRules {2847  //`const` requires the field value to exactly match the specified bytes2848  //value. If the field value doesn't match, an error message is generated.2849  //2850  //```proto2851  //message MyBytes {2852  //  // value must be "\x01\x02\x03\x04"2853  //   bytes value = 1 [(buf.validate.field).bytes.const = "\x01\x02\x03\x04"];2854  //}2855  //```2856  optional bytes const = 1 [(priv.field).cel = {2857    id: "bytes.const",2858    expression: "this != rules.const ? 'value must be %x'.format([rules.const]) : ''"2859  }];28602861  //`len` requires the field value to have the specified length in bytes.2862  //If the field value doesn't match, an error message is generated.2863  //2864  //```proto2865  //message MyBytes {2866  //      // value length must be 4 bytes.2867  //      optional bytes value = 1 [(buf.validate.field).bytes.len = 4];2868  //}2869  //```2870  optional uint64 len = 13 [(priv.field).cel = {2871    id: "bytes.len",2872    expression: "this.size() != int(rules.len) ? 'value length must be %s bytes'.format([rules.len]) : ''"2873  }];28742875  //`min_len` requires the field value to have at least the specified minimum2876  //length in bytes.2877  //If the field value doesn't meet the requirement, an error message is generated.2878  //2879  //```proto2880  //message MyBytes {2881  // // value must be at least 2 bytes.2882  // optional bytes value = 1 [(buf.validate.field).bytes.min_len = 2];2883  //}2884  //```2885  optional uint64 min_len = 2 [(priv.field).cel = {2886    id: "bytes.min_len",2887    expression: "this.size() < int(rules.min_len) ? 'value must be at least %s bytes'.format([rules.min_len]) : ''"2888  }];28892890  //`max_len` requires the field value to have at most the specified maximum2891  //length in bytes.2892  //If the field value exceeds the requirement, an error message is generated.2893  //2894  //```proto2895  //message MyBytes {2896  // // value must be at most 6 bytes.2897  // optional bytes value = 1 [(buf.validate.field).bytes.max_len = 6];2898  //}2899  //```2900  optional uint64 max_len = 3 [(priv.field).cel = {2901    id: "bytes.max_len",2902    expression: "this.size() > int(rules.max_len) ? 'value must be at most %s bytes'.format([rules.max_len]) : ''"2903  }];29042905  //`pattern` requires the field value to match the specified regular2906  //expression ([RE2 syntax](https://github.com/google/re2/wiki/Syntax)).2907  //The value of the field must be valid UTF-8 or validation will fail with a2908  //runtime error.2909  //If the field value doesn't match the pattern, an error message is generated.2910  //2911  //```proto2912  //message MyBytes {2913  // // value must match pattern "^[a-zA-Z0-9]+$".2914  // optional bytes value = 1 [(buf.validate.field).bytes.pattern = "^[a-zA-Z0-9]+$"];2915  //}2916  //```2917  optional string pattern = 4 [(priv.field).cel = {2918    id: "bytes.pattern",2919    expression: "!string(this).matches(rules.pattern) ? 'value must match pattern %s'.format([rules.pattern]) : ''"2920  }];29212922  //`prefix` requires the field value to have the specified bytes at the2923  //beginning of the string.2924  //If the field value doesn't meet the requirement, an error message is generated.2925  //2926  //```proto2927  //message MyBytes {2928  //// value does not have prefix \x01\x022929  //optional bytes value = 1 [(buf.validate.field).bytes.prefix = "\x01\x02"];2930  //}2931  //```2932  optional bytes prefix = 5 [(priv.field).cel = {2933    id: "bytes.prefix",2934    expression: "!this.startsWith(rules.prefix) ? 'value does not have prefix %x'.format([rules.prefix]) : ''"2935  }];29362937  //`suffix` requires the field value to have the specified bytes at the end2938  //of the string.2939  //If the field value doesn't meet the requirement, an error message is generated.2940  //2941  //```proto2942  //message MyBytes {2943  // // value does not have suffix \x03\x042944  // optional bytes value = 1 [(buf.validate.field).bytes.suffix = "\x03\x04"];2945  //}2946  //```2947  optional bytes suffix = 6 [(priv.field).cel = {2948    id: "bytes.suffix",2949    expression: "!this.endsWith(rules.suffix) ? 'value does not have suffix %x'.format([rules.suffix]) : ''"2950  }];29512952  //`contains` requires the field value to have the specified bytes anywhere in2953  //the string.2954  //If the field value doesn't meet the requirement, an error message is generated.2955  //2956  //```protobuf2957  //message MyBytes {2958  // // value does not contain \x02\x032959  // optional bytes value = 1 [(buf.validate.field).bytes.contains = "\x02\x03"];2960  //}2961  //```2962  optional bytes contains = 7 [(priv.field).cel = {2963    id: "bytes.contains",2964    expression: "!this.contains(rules.contains) ? 'value does not contain %x'.format([rules.contains]) : ''"2965  }];29662967  //`in` requires the field value to be equal to one of the specified2968  //values. If the field value doesn't match any of the specified values, an2969  //error message is generated.2970  //2971  //```protobuf2972  //message MyBytes {2973  // // value must in ["\x01\x02", "\x02\x03", "\x03\x04"]2974  // optional bytes value = 1 [(buf.validate.field).bytes.in = {"\x01\x02", "\x02\x03", "\x03\x04"}];2975  //}2976  //```2977  repeated bytes in = 8 [(priv.field).cel = {2978    id: "bytes.in",2979    expression: "dyn(rules)['in'].size() > 0 && !(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''"2980  }];29812982  //`not_in` requires the field value to be not equal to any of the specified2983  //values.2984  //If the field value matches any of the specified values, an error message is2985  //generated.2986  //2987  //```proto2988  //message MyBytes {2989  // // value must not in ["\x01\x02", "\x02\x03", "\x03\x04"]2990  // optional bytes value = 1 [(buf.validate.field).bytes.not_in = {"\x01\x02", "\x02\x03", "\x03\x04"}];2991  //}2992  //```2993  repeated bytes not_in = 9 [(priv.field).cel = {2994    id: "bytes.not_in",2995    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''"2996  }];29972998  // WellKnown rules provide advanced constraints against common byte2999  // patterns3000  oneof well_known {3001    //`ip` ensures that the field `value` is a valid IP address (v4 or v6) in byte format.3002    //If the field value doesn't meet this constraint, an error message is generated.3003    //3004    //```proto3005    //message MyBytes {3006    // // value must be a valid IP address3007    // optional bytes value = 1 [(buf.validate.field).bytes.ip = true];3008    //}3009    //```3010    bool ip = 10 [(priv.field).cel = {3011      id: "bytes.ip",3012      expression: "this.size() != 4 && this.size() != 16 ? 'value must be a valid IP address' : ''"3013    }];30143015    //`ipv4` ensures that the field `value` is a valid IPv4 address in byte format.3016    //If the field value doesn't meet this constraint, an error message is generated.3017    //3018    //```proto3019    //message MyBytes {3020    // // value must be a valid IPv4 address3021    // optional bytes value = 1 [(buf.validate.field).bytes.ipv4 = true];3022    //}3023    //```3024    bool ipv4 = 11 [(priv.field).cel = {3025      id: "bytes.ipv4",3026      expression: "this.size() != 4 ? 'value must be a valid IPv4 address' : ''"3027    }];30283029    //`ipv6` ensures that the field `value` is a valid IPv6 address in byte format.3030    //If the field value doesn't meet this constraint, an error message is generated.3031    //```proto3032    //message MyBytes {3033    // // value must be a valid IPv6 address3034    // optional bytes value = 1 [(buf.validate.field).bytes.ipv6 = true];3035    //}3036    //```3037    bool ipv6 = 12 [(priv.field).cel = {3038      id: "bytes.ipv6",3039      expression: "this.size() != 16 ? 'value must be a valid IPv6 address' : ''"3040    }];3041  }3042}30433044// EnumRules describe the constraints applied to `enum` values.3045message EnumRules {3046  //`const` requires the field value to exactly match the specified enum value.3047  //If the field value doesn't match, an error message is generated.3048  //3049  //```proto3050  //enum MyEnum {3051  //  MY_ENUM_UNSPECIFIED = 0;3052  //  MY_ENUM_VALUE1 = 1;3053  //  MY_ENUM_VALUE2 = 2;3054  //}3055  //3056  //message MyMessage {3057  //  // The field `value` must be exactly MY_ENUM_VALUE1.3058  //   MyEnum value = 1 [(buf.validate.field).enum.const = 1];3059  //}3060  //```3061  optional int32 const = 1 [(priv.field).cel = {3062    id: "enum.const",3063    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",3064  }];30653066  //`defined_only` requires the field value to be one of the defined values for3067  // this enum, failing on any undefined value.3068  //3069  //```proto3070  //enum MyEnum {3071  //  MY_ENUM_UNSPECIFIED = 0;3072  //  MY_ENUM_VALUE1 = 1;3073  //  MY_ENUM_VALUE2 = 2;3074  //}3075  //3076  //message MyMessage {3077  //  // The field `value` must be a defined value of MyEnum.3078  //   MyEnum value = 1 [(buf.validate.field).enum.defined_only = true];3079  //}3080  //```3081  optional bool defined_only = 2;30823083  //`in` requires the field value to be equal to one of the3084  //specified enum values. If the field value doesn't match any of the3085  //specified values, an error message is generated.3086  //3087  //```proto3088  //enum MyEnum {3089  //  MY_ENUM_UNSPECIFIED = 0;3090  //  MY_ENUM_VALUE1 = 1;3091  //  MY_ENUM_VALUE2 = 2;3092  //}3093  //3094  //message MyMessage {3095  //  // The field `value` must be equal to one of the specified values.3096  //   MyEnum value = 1 [(buf.validate.field).enum.in = {1, 2}];3097  //}3098  //```3099  repeated int32 in = 3 [(priv.field).cel = {3100    id: "enum.in",3101    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",3102  }];31033104  //`not_in` requires the field value to be not equal to any of the3105  //specified enum values. If the field value matches one of the specified3106  //values, an error message is generated.3107  //3108  //```proto3109  //enum MyEnum {3110  //  MY_ENUM_UNSPECIFIED = 0;3111  //  MY_ENUM_VALUE1 = 1;3112  //  MY_ENUM_VALUE2 = 2;3113  //}3114  //3115  //message MyMessage {3116  //  // The field `value` must not be equal to any of the specified values.3117  //   MyEnum value = 1 [(buf.validate.field).enum.not_in = {1, 2}];3118  //}3119  //```3120  repeated int32 not_in = 4 [(priv.field).cel = {3121    id: "enum.not_in",3122    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",3123  }];3124}31253126// RepeatedRules describe the constraints applied to `repeated` values.3127message RepeatedRules {3128  //`min_items` requires that this field must contain at least the specified3129  //minimum number of items.3130  //3131  //```proto3132  //message MyRepeated {3133  //  // value must contain at least  2 items3134  //  repeated string value = 1 [(buf.validate.field).repeated.min_items = 2];3135  //}3136  //```3137  optional uint64 min_items = 1 [(priv.field).cel = {3138    id: "repeated.min_items"3139    expression: "this.size() < rules.min_items ? 'value must contain at least %d item(s)'.format([rules.min_items]) : ''"3140  }];31413142  //`max_items` denotes that this field must not exceed a3143  //certain number of items as the upper limit. If the field contains more3144  //items than specified, an error message will be generated, requiring the3145  //field to maintain no more than the specified number of items.3146  //3147  //```proto3148  //message MyRepeated {3149  //  // value must contain no more than 3 item(s)3150  //  repeated string value = 1 [(buf.validate.field).repeated.max_items = 3];3151  //}3152  //```3153  optional uint64 max_items = 2 [(priv.field).cel = {3154    id: "repeated.max_items"3155    expression: "this.size() > rules.max_items ? 'value must contain no more than %s item(s)'.format([rules.max_items]) : ''"3156  }];31573158  //`unique` indicates that all elements in this field must3159  //be unique. This constraint is strictly applicable to scalar and enum3160  //types, with message types not being supported.3161  //3162  //```proto3163  //message MyRepeated {3164  // // repeated value must contain unique items3165  // repeated string value = 1 [(buf.validate.field).repeated.unique = true];3166  //}3167  //```3168  optional bool unique = 3 [(priv.field).cel = {3169    id: "repeated.unique"3170    message: "repeated value must contain unique items"3171    expression: "this.unique()"3172  }];31733174  //`items` details the constraints to be applied to each item3175  //in the field. Even for repeated message fields, validation is executed3176  //against each item unless skip is explicitly specified.3177  //3178  //```proto3179  //message MyRepeated {3180  //  // The items in the field `value` must follow the specified constraints.3181  //  repeated string value = 1 [(buf.validate.field).repeated.items = {3182  //    string: {3183  //      min_len: 33184  //      max_len: 103185  //    }3186  //  }];3187  //}3188  optional FieldConstraints items = 4;3189}31903191// MapRules describe the constraints applied to `map` values.3192message MapRules {3193  //Specifies the minimum number of key-value pairs allowed. If the field has3194  //fewer key-value pairs than specified, an error message is generated.3195  //3196  //```proto3197  //message MyMap {3198  //  // The field `value` must have at least 2 key-value pairs.3199  //  map<string, string> value = 1 [(buf.validate.field).map.min_pairs = 2];3200  //}3201  //```3202  optional uint64 min_pairs = 1 [(priv.field).cel = {3203    id: "map.min_pairs"3204    expression: "this.size() < rules.min_pairs ? 'map must be at least %d entries'.format([rules.min_pairs]) : ''"3205  }];32063207  //Specifies the maximum number of key-value pairs allowed. If the field has3208  //more key-value pairs than specified, an error message is generated.3209  //3210  //```proto3211  //message MyMap {3212  //  // The field `value` must have at most 3 key-value pairs.3213  //  map<string, string> value = 1 [(buf.validate.field).map.max_pairs = 3];3214  //}3215  //```3216  optional uint64 max_pairs = 2 [(priv.field).cel = {3217    id: "map.max_pairs"3218    expression: "this.size() > rules.max_pairs ? 'map must be at most %d entries'.format([rules.max_pairs]) : ''"3219  }];32203221  //Specifies the constraints to be applied to each key in the field.3222  //3223  //```proto3224  //message MyMap {3225  //  // The keys in the field `value` must follow the specified constraints.3226  //  map<string, string> value = 1 [(buf.validate.field).map.keys = {3227  //    string: {3228  //      min_len: 33229  //      max_len: 103230  //    }3231  //  }];3232  //}3233  //```3234  optional FieldConstraints keys = 4;32353236  //Specifies the constraints to be applied to the value of each key in the3237  //field. Message values will still have their validations evaluated unless3238  //skip is specified here.3239  //3240  //```proto3241  //message MyMap {3242  //  // The values in the field `value` must follow the specified constraints.3243  //  map<string, string> value = 1 [(buf.validate.field).map.values = {3244  //    string: {3245  //      min_len: 53246  //      max_len: 203247  //    }3248  //  }];3249  //}3250  //```3251  optional FieldConstraints values = 5;3252}32533254// AnyRules describe constraints applied exclusively to the `google.protobuf.Any` well-known type.3255message AnyRules {3256  //`in` requires the field's `type_url` to be equal to one of the3257  //specified values. If it doesn't match any of the specified values, an error3258  //message is generated.3259  //3260  //```proto3261  //message MyAny {3262  //  //  The `value` field must have a `type_url` equal to one of the specified values.3263  //   google.protobuf.Any value = 1 [(buf.validate.field).any.in = ["type.googleapis.com/MyType1", "type.googleapis.com/MyType2"]];3264  //}3265  //```3266  repeated string in = 2;32673268  // 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.3269  //3270  //```proto3271  //message MyAny {3272  //  // The field `value` must not have a `type_url` equal to any of the specified values.3273  //   google.protobuf.Any value = 1 [(buf.validate.field).any.not_in = ["type.googleapis.com/ForbiddenType1", "type.googleapis.com/ForbiddenType2"]];3274  //}3275  //```3276  repeated string not_in = 3;3277}32783279// DurationRules describe the constraints applied exclusively to the `google.protobuf.Duration` well-known type.3280message DurationRules {3281  //`const` dictates that the field must match the specified value of the `google.protobuf.Duration` type exactly.3282  //If the field's value deviates from the specified value, an error message3283  //will be generated.3284  //3285  //```proto3286  //message MyDuration {3287  //  // value must equal 5s3288  //   google.protobuf.Duration value = 1 [(buf.validate.field).duration.const = "5s"];3289  //}3290  //```3291  optional google.protobuf.Duration const = 2 [(priv.field).cel = {3292    id: "duration.const",3293    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",3294  }];32953296  //`lt` stipulates that the field must be less than the specified value of the `google.protobuf.Duration` type,3297  //exclusive. If the field's value is greater than or equal to the specified3298  //value, an error message will be generated.3299  //3300  //```proto3301  //message MyDuration {3302  //  // value must be less than 5s3303  //   google.protobuf.Duration value = 1 [(buf.validate.field).duration.lt = "5s"];3304  //}3305  //```3306  optional google.protobuf.Duration lt = 3 [(priv.field).cel = {3307    id: "duration.lt",3308    expression:3309      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt"3310      "? 'value must be less than %s'.format([rules.lt]) : ''"3311  }];33123313  //`lte` indicates that the field must be less than or equal to the specified3314  //value of the `google.protobuf.Duration` type, inclusive. If the field's value is greater than the specified value,3315  //an error message will be generated.3316  //3317  //```proto3318  //message MyDuration {3319  //  // value must be less than or equal to 10s3320  //   google.protobuf.Duration value = 1 [(buf.validate.field).duration.lte = "10s"];3321  //}3322  //```3323  optional google.protobuf.Duration lte = 4 [(priv.field).cel = {3324    id: "duration.lte",3325    expression:3326      "!has(rules.gte) && !has(rules.gt) && this > rules.lte"3327      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''"3328  }];33293330  // `gt` requires the duration field value to be greater than the specified3331  // value (exclusive). If the value of `gt` is larger than a specified `lt`3332  // or `lte`, the range is reversed, and the field value must be outside the3333  // specified range. If the field value doesn't meet the required conditions,3334  // an error message is generated.3335  //3336  //```proto3337  //message MyDuration {3338  //  // duration must be greater than 5s [duration.gt]3339  //  google.protobuf.Duration value = 1 [(buf.validate.field).duration.gt = { seconds: 5 }];3340  //3341  //  // duration must be greater than 5s and less than 10s [duration.gt_lt]3342  //  google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gt: { seconds: 5 }, lt: { seconds: 10 } }];3343  //3344  //  // duration must be greater than 10s or less than 5s [duration.gt_lt_exclusive]3345  //  google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gt: { seconds: 10 }, lt: { seconds: 5 } }];3346  //}3347  //```3348  optional google.protobuf.Duration gt = 5 [3349    (priv.field).cel = {3350      id: "duration.gt",3351      expression:3352        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"3353        "? 'value must be greater than %s'.format([rules.gt]) : ''"3354    },3355    (priv.field).cel = {3356      id: "duration.gt_lt",3357      expression:3358        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"3359        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"3360    },3361    (priv.field).cel = {3362      id: "duration.gt_lt_exclusive",3363      expression:3364        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"3365        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"3366    },3367    (priv.field).cel = {3368      id: "duration.gt_lte",3369      expression:3370        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"3371        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"3372    },3373    (priv.field).cel = {3374      id: "duration.gt_lte_exclusive",3375      expression:3376        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"3377        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"3378    }3379  ];33803381  // `gte` requires the duration field value to be greater than or equal to the3382  // specified value (exclusive). If the value of `gte` is larger than a3383  // specified `lt` or `lte`, the range is reversed, and the field value must3384  // be outside the specified range. If the field value doesn't meet the3385  // required conditions, an error message is generated.3386  //3387  //```proto3388  //message MyDuration {3389  //  // duration must be greater than or equal to 5s [duration.gte]3390  //  google.protobuf.Duration value = 1 [(buf.validate.field).duration.gte = { seconds: 5 }];3391  //3392  //  // duration must be greater than or equal to 5s and less than 10s [duration.gte_lt]3393  //  google.protobuf.Duration another_value = 2 [(buf.validate.field).duration = { gte: { seconds: 5 }, lt: { seconds: 10 } }];3394  //3395  //  // duration must be greater than or equal to 10s or less than 5s [duration.gte_lt_exclusive]3396  //  google.protobuf.Duration other_value = 3 [(buf.validate.field).duration = { gte: { seconds: 10 }, lt: { seconds: 5 } }];3397  //}3398  //```3399  optional google.protobuf.Duration gte = 6 [3400    (priv.field).cel = {3401      id: "duration.gte",3402      expression:3403        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"3404        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"3405    },3406    (priv.field).cel = {3407      id: "duration.gte_lt",3408      expression:3409        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"3410        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"3411    },3412    (priv.field).cel = {3413      id: "duration.gte_lt_exclusive",3414      expression:3415        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"3416        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"3417    },3418    (priv.field).cel = {3419      id: "duration.gte_lte",3420      expression:3421        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"3422        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"3423    },3424    (priv.field).cel = {3425      id: "duration.gte_lte_exclusive",3426      expression:3427        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"3428        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"3429    }3430  ];34313432  //`in` asserts that the field must be equal to one of the specified values of the `google.protobuf.Duration` type.3433  //If the field's value doesn't correspond to any of the specified values,3434  //an error message will be generated.3435  //3436  //```proto3437  //message MyDuration {3438  //  // value must be in list [1s, 2s, 3s]3439  //   google.protobuf.Duration value = 1 [(buf.validate.field).duration.in = ["1s", "2s", "3s"]];3440  //}3441  //```3442  repeated google.protobuf.Duration in = 7 [(priv.field).cel = {3443    id: "duration.in",3444    expression: "!(this in dyn(rules)['in']) ? 'value must be in list %s'.format([dyn(rules)['in']]) : ''",3445  }];34463447  //`not_in` denotes that the field must not be equal to3448  //any of the specified values of the `google.protobuf.Duration` type.3449  //If the field's value matches any of these values, an error message will be3450  //generated.3451  //3452  //```proto3453  //message MyDuration {3454  //  // value must not be in list [1s, 2s, 3s]3455  //   google.protobuf.Duration value = 1 [(buf.validate.field).duration.not_in = ["1s", "2s", "3s"]];3456  //}3457  //```3458  repeated google.protobuf.Duration not_in = 8 [(priv.field).cel = {3459    id: "duration.not_in",3460    expression: "this in rules.not_in ? 'value must not be in list %s'.format([rules.not_in]) : ''",3461  }];3462}34633464// TimestampRules describe the constraints applied exclusively to the `google.protobuf.Timestamp` well-known type.3465message TimestampRules {3466  //`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.3467  //3468  //```proto3469  //message MyTimestamp {3470  //  // value must equal 2023-05-03T10:00:00Z3471  //   google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.const = {seconds: 1727998800}];3472  //}3473  //```3474  optional google.protobuf.Timestamp const = 2 [(priv.field).cel = {3475    id: "timestamp.const",3476    expression: "this != rules.const ? 'value must equal %s'.format([rules.const]) : ''",3477  }];34783479  // 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.3480  //3481  // ```proto3482  // message MyDuration {3483  //   // duration must be less than 'P3D' [duration.lt]3484  //   google.protobuf.Duration value = 1 [(buf.validate.field).duration.lt = { seconds: 259200 }];3485  // }3486  // ```3487  optional google.protobuf.Timestamp lt = 3 [(priv.field).cel = {3488    id: "timestamp.lt",3489    expression:3490      "!has(rules.gte) && !has(rules.gt) && this >= rules.lt"3491      "? 'value must be less than %s'.format([rules.lt]) : ''"3492  }];34933494  // 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.3495  //3496  // ```proto3497  // message MyTimestamp {3498  //   // timestamp must be less than or equal to '2023-05-14T00:00:00Z' [timestamp.lte]3499  //   google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.lte = { seconds: 1678867200 }];3500  // }3501  // ```3502  optional google.protobuf.Timestamp lte = 4 [(priv.field).cel = {3503    id: "timestamp.lte",3504    expression:3505      "!has(rules.gte) && !has(rules.gt) && this > rules.lte"3506      "? 'value must be less than or equal to %s'.format([rules.lte]) : ''"3507  }];35083509  //`gt` requires the timestamp field value to be greater than the specified3510  // value (exclusive). If the value of `gt` is larger than a specified `lt`3511  // or `lte`, the range is reversed, and the field value must be outside the3512  // specified range. If the field value doesn't meet the required conditions,3513  // an error message is generated.3514  //3515  //```proto3516  //message MyTimestamp {3517  //  // timestamp must be greater than '2023-01-01T00:00:00Z' [timestamp.gt]3518  //  google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.gt = { seconds: 1672444800 }];3519  //3520  //  // timestamp must be greater than '2023-01-01T00:00:00Z' and less than '2023-01-02T00:00:00Z' [timestamp.gt_lt]3521  //  google.protobuf.Timestamp another_value = 2 [(buf.validate.field).timestamp = { gt: { seconds: 1672444800 }, lt: { seconds: 1672531200 } }];3522  //3523  //  // timestamp must be greater than '2023-01-02T00:00:00Z' or less than '2023-01-01T00:00:00Z' [timestamp.gt_lt_exclusive]3524  //  google.protobuf.Timestamp other_value = 3 [(buf.validate.field).timestamp = { gt: { seconds: 1672531200 }, lt: { seconds: 1672444800 } }];3525  //}3526  //```3527  optional google.protobuf.Timestamp gt = 5 [3528    (priv.field).cel = {3529      id: "timestamp.gt",3530      expression:3531        "!has(rules.lt) && !has(rules.lte) && this <= rules.gt"3532        "? 'value must be greater than %s'.format([rules.gt]) : ''"3533    },3534    (priv.field).cel = {3535      id: "timestamp.gt_lt",3536      expression:3537        "has(rules.lt) && rules.lt >= rules.gt && (this >= rules.lt || this <= rules.gt)"3538        "? 'value must be greater than %s and less than %s'.format([rules.gt, rules.lt]) : ''"3539    },3540    (priv.field).cel = {3541      id: "timestamp.gt_lt_exclusive",3542      expression:3543        "has(rules.lt) && rules.lt < rules.gt && (rules.lt <= this && this <= rules.gt)"3544        "? 'value must be greater than %s or less than %s'.format([rules.gt, rules.lt]) : ''"3545    },3546    (priv.field).cel = {3547      id: "timestamp.gt_lte",3548      expression:3549        "has(rules.lte) && rules.lte >= rules.gt && (this > rules.lte || this <= rules.gt)"3550        "? 'value must be greater than %s and less than or equal to %s'.format([rules.gt, rules.lte]) : ''"3551    },3552    (priv.field).cel = {3553      id: "timestamp.gt_lte_exclusive",3554      expression:3555        "has(rules.lte) && rules.lte < rules.gt && (rules.lte < this && this <= rules.gt)"3556        "? 'value must be greater than %s or less than or equal to %s'.format([rules.gt, rules.lte]) : ''"3557    }3558  ];35593560  //`gte` requires the timestamp field value to be greater than or equal to the3561  // specified value (exclusive). If the value of `gte` is larger than a3562  // specified `lt` or `lte`, the range is reversed, and the field value3563  // must be outside the specified range. If the field value doesn't meet3564  // the required conditions, an error message is generated.3565  //3566  //```proto3567  //message MyTimestamp {3568  //  // timestamp must be greater than or equal to '2023-01-01T00:00:00Z' [timestamp.gte]3569  //  google.protobuf.Timestamp value = 1 [(buf.validate.field).timestamp.gte = { seconds: 1672444800 }];3570  //3571  //  // timestamp must be greater than or equal to '2023-01-01T00:00:00Z' and less than '2023-01-02T00:00:00Z' [timestamp.gte_lt]3572  //  google.protobuf.Timestamp another_value = 2 [(buf.validate.field).timestamp = { gte: { seconds: 1672444800 }, lt: { seconds: 1672531200 } }];3573  //3574  //  // 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]3575  //  google.protobuf.Timestamp other_value = 3 [(buf.validate.field).timestamp = { gte: { seconds: 1672531200 }, lt: { seconds: 1672444800 } }];3576  //}3577  //```3578  optional google.protobuf.Timestamp gte = 6 [3579    (priv.field).cel = {3580      id: "timestamp.gte",3581      expression:3582        "!has(rules.lt) && !has(rules.lte) && this < rules.gte"3583        "? 'value must be greater than or equal to %s'.format([rules.gte]) : ''"3584    },3585    (priv.field).cel = {3586      id: "timestamp.gte_lt",3587      expression:3588        "has(rules.lt) && rules.lt >= rules.gte && (this >= rules.lt || this < rules.gte)"3589        "? 'value must be greater than or equal to %s and less than %s'.format([rules.gte, rules.lt]) : ''"3590    },3591    (priv.field).cel = {3592      id: "timestamp.gte_lt_exclusive",3593      expression:3594        "has(rules.lt) && rules.lt < rules.gte && (rules.lt <= this && this < rules.gte)"3595        "? 'value must be greater than or equal to %s or less than %s'.format([rules.gte, rules.lt]) : ''"3596    },3597    (priv.field).cel = {3598      id: "timestamp.gte_lte",3599      expression:3600        "has(rules.lte) && rules.lte >= rules.gte && (this > rules.lte || this < rules.gte)"3601        "? 'value must be greater than or equal to %s and less than or equal to %s'.format([rules.gte, rules.lte]) : ''"3602    },3603    (priv.field).cel = {3604      id: "timestamp.gte_lte_exclusive",3605      expression:3606        "has(rules.lte) && rules.lte < rules.gte && (rules.lte < this && this < rules.gte)"3607        "? 'value must be greater than or equal to %s or less than or equal to %s'.format([rules.gte, rules.lte]) : ''"3608    }3609  ];36103611  //`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.3612  //3613  //```proto3614  //message MyTimestamp {3615  //  // value must be less than now3616  //   google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.lt_now = true];3617  //}3618  //```3619  optional bool lt_now = 7 [(priv.field).cel = {3620    id: "timestamp.lt_now",3621    expression: "this > now ? 'value must be less than now' : ''"3622  }];36233624  //`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.3625  //3626  //```proto3627  //message MyTimestamp {3628  //  // value must be greater than now3629  //   google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.gt_now = true];3630  //}3631  //```3632  optional bool gt_now = 8 [(priv.field).cel = {3633    id: "timestamp.gt_now",3634    expression: "this < now ? 'value must be greater than now' : ''"3635  }];36363637  // `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.3638  //3639  //```proto3640  //message MyTimestamp {3641  //  // value must be within 1 hour of now3642  //   google.protobuf.Timestamp created_at = 1 [(buf.validate.field).timestamp.within = {seconds: 3600}];3643  //}3644  //```3645  optional google.protobuf.Duration within = 9 [(priv.field).cel = {3646    id: "timestamp.within",3647    expression: "this < now-rules.within || this > now+rules.within ? 'value must be within %s of now'.format([rules.within]) : ''"3648  }];3649}