From a1dd1287d933fcaa1756e1f9de27462e24f6a02c Mon Sep 17 00:00:00 2001 From: unmultimedio <4431392+unmultimedio@users.noreply.github.com> Date: Fri, 4 Oct 2024 12:05:38 +0000 Subject: [PATCH] Detected new managed modules references --- ...fad44f7786bf040b3d54c954bfd7268fc19fa499ca | 37 ++ ...2b78dd89be559109866853742cf607619fe1672563 | 361 +++++++++++++++++ ...63b42cf9c558955611f440e4901b3c26bda89b99ab | 224 +++++++++++ ...d3fa4e44bbf39d70322a201a80fc37c67bb34e7d77 | 373 ++++++++++++++++++ .../bufbuild/protovalidate-testing/state.json | 4 + .../sync/bufbuild/protovalidate/state.json | 4 + modules/sync/googleapis/googleapis/state.json | 52 +++ modules/sync/state.json | 6 +- 8 files changed, 1058 insertions(+), 3 deletions(-) create mode 100644 modules/sync/bufbuild/protovalidate-testing/cas/12504b9b4ef92597af595e1fafcdc1379fb1f25086c73b279538473fb81806c825c111270a553170140039fad44f7786bf040b3d54c954bfd7268fc19fa499ca create mode 100644 modules/sync/bufbuild/protovalidate-testing/cas/1a324ec70b9778966d351c543c70f73ad942c82ea3c8ed24ec10f26ff6d4676f440f68a4c49d5be1b16cbd2b78dd89be559109866853742cf607619fe1672563 create mode 100644 modules/sync/bufbuild/protovalidate-testing/cas/52e8ba9cc75e6d9bbb6f48260eac0aa081732f3a8465e906d7be70a55c3dcbe6912b6e05ee9b2f961c415463b42cf9c558955611f440e4901b3c26bda89b99ab create mode 100644 modules/sync/bufbuild/protovalidate-testing/cas/90c883c4a724a8634456bc03bdad9da5e45fd4741afb50d795e545d143ae8634865ecc78d4f1772cf4887ad3fa4e44bbf39d70322a201a80fc37c67bb34e7d77 diff --git a/modules/sync/bufbuild/protovalidate-testing/cas/12504b9b4ef92597af595e1fafcdc1379fb1f25086c73b279538473fb81806c825c111270a553170140039fad44f7786bf040b3d54c954bfd7268fc19fa499ca b/modules/sync/bufbuild/protovalidate-testing/cas/12504b9b4ef92597af595e1fafcdc1379fb1f25086c73b279538473fb81806c825c111270a553170140039fad44f7786bf040b3d54c954bfd7268fc19fa499ca new file mode 100644 index 00000000..bea734b5 --- /dev/null +++ b/modules/sync/bufbuild/protovalidate-testing/cas/12504b9b4ef92597af595e1fafcdc1379fb1f25086c73b279538473fb81806c825c111270a553170140039fad44f7786bf040b3d54c954bfd7268fc19fa499ca @@ -0,0 +1,37 @@ +shake256:8f88503768991dcc77b5a39a4a8d3374c99f4f0f69fb9e58a383fa238b20645190dc4570817b8ab9bbd83e90d063d151048137ef8c6bdb51ea797f7c6f41cfba LICENSE +shake256:838f55cc2961a34975d1b9545ed659d80c69dd0f61850ddad867a44615e5aab920a056524a4464e8760f68924ae89b6fae6d39c56908113e9ac2cbc78c911deb README.md +shake256:65b08da2d767089fbe072c7a3aa693485a319e609210e9f504f89aae9991e0e7b68e58c3720584976b05b99fb3c1ca9adc76d27285a40d7d13bd410d1f342dda buf.yaml +shake256:dc07664bb57896d98642cd4f2e32ec850fb415bd52c99485b3656d0eb3855432ca119df1704b310d6c2e118e1942aa942a0cc4016d5ae1a690382cd837e7ca88 buf/validate/conformance/cases/bool.proto +shake256:345b58d0fbad1b6933f5150e5be48c7902267bf0df5ea4e1522f9ef1855d0826d78781e36d7cc7ffa8048219eec504ba03cfeabe8ec2dc7608320fce8ac68d63 buf/validate/conformance/cases/bytes.proto +shake256:f9a242cffcb818f119813e299e2014fc769526fcd515e622c937021fb0cd029e841aef801e1cba565f148cf241261ee337307217e953eb059bc4c6761e98862a buf/validate/conformance/cases/custom_constraints/custom_constraints.proto +shake256:6725a5f04c2640cc50e9986cb7a538a05af713f96d6f716af726f3fcc3b9f0ab026db17fd6da1e0e0b1f278be88aa5653f95e5f8eb585cef0c29e8bb6aeea034 buf/validate/conformance/cases/enums.proto +shake256:f27bc7f3fc084c84cd163322bdaa850cf923b9efaaa6ecca3466f51f0898fafe9a6fa00cd4b3af071382c30921b3f19e1fe6fb7c35f50069f92a7a4f84364697 buf/validate/conformance/cases/filename-with-dash.proto +shake256:4bbeb1673369de1160203c5b27d63acd505b14b5ca4137058698df49c20f64e38f7955fddff6bfcf75e18c702c8c2d8744096cb1e0be73a49e2adfe7d5e69ab7 buf/validate/conformance/cases/ignore_empty_proto2.proto +shake256:a854da7737363b819c899ad0407b1a69401845ec54f0aa2f27f89b8f1037588118a195db5aa7a7593ab3b94076ceb1453a30b81ce40a4b2876fb9e1cbf3202cf buf/validate/conformance/cases/ignore_empty_proto3.proto +shake256:030d61341e8d3fcf1006a0e4c494ad48e4642421ccc08b723e1042b5df95849a540c5152ed8fe3048520e14b790adb427ad81617828e3970375662c14f7a61c5 buf/validate/conformance/cases/ignore_empty_proto_editions.proto +shake256:1518de9df4730277e5109a92ca0f5b3a3d979de94bc404d10093a181c1b968ad9979a37be548f3dc3caa591dadae025ab59df4d212313ccf0de246e4b64d77f7 buf/validate/conformance/cases/ignore_proto2.proto +shake256:b68a8f52254a2d82af7ad70260d9de268199f17214b32904e3bef2b85a47c9ee26682b81c1f844de4f51fc03232c0a5e8d5443cba2b10e70cea7fec005fdb333 buf/validate/conformance/cases/ignore_proto3.proto +shake256:1329fa737f9d05ccd41b87803c44f5c7a513c060b552d2cab26741ecbff8438e593b6d66aebff840e88fc6058c3d912b18a955c28cca0f49dbd500c8188b46fb buf/validate/conformance/cases/ignore_proto_editions.proto +shake256:8b1bee8d27493c60da734d3e16a620c8520f6126a682bd5764b7d861c08cd916315cd01e2fa6e30925e8fa3a809f3c0b77048dcad82b5c14c6e8d61ba23627d3 buf/validate/conformance/cases/kitchen_sink.proto +shake256:487cc8247d064cfc75fb95d6ab886e1532c85efff42d135bec5c4c321cde720d8c91fbf08967750cf281a9db2191a013ac963e9b6fde071983a126c707778cc3 buf/validate/conformance/cases/maps.proto +shake256:98e5d516b88da150d62f3aaa5e2f1eda4cd48cdb6300933f7efcb7337b82388cdb0061980b4dec00f35c0eb92426283e07e673bbdd5f81168c3767704747daba buf/validate/conformance/cases/messages.proto +shake256:6a3c3dc4caafab27447b8dea8dced2ec180bf2a1148afb388f39756370b9730d74d8ef390532b3ff8968eb6d284f6a7e9794b0e40e9153a0b6a186c0c313e57d buf/validate/conformance/cases/numbers.proto +shake256:749cd37bcb4b2ae2c20e858d97e7b5a7ab1cb69bc8a7512bea77160810c3e6d114d6c424047364a8ae9f2a823ab6e51f69f1825d5a9f0ec81371806ccae2b672 buf/validate/conformance/cases/oneofs.proto +shake256:50633a57b483850fb64e06c1bcd0eb545c8a359a940dd4d92ef1e14232e05ab6f8194e89f1b5fadab5722f1b2f7eb240036b034018ea3437c23039eab1e9db5c buf/validate/conformance/cases/other_package/embed.proto +shake256:1a324ec70b9778966d351c543c70f73ad942c82ea3c8ed24ec10f26ff6d4676f440f68a4c49d5be1b16cbd2b78dd89be559109866853742cf607619fe1672563 buf/validate/conformance/cases/predefined_rules_proto2.proto +shake256:52e8ba9cc75e6d9bbb6f48260eac0aa081732f3a8465e906d7be70a55c3dcbe6912b6e05ee9b2f961c415463b42cf9c558955611f440e4901b3c26bda89b99ab buf/validate/conformance/cases/predefined_rules_proto3.proto +shake256:90c883c4a724a8634456bc03bdad9da5e45fd4741afb50d795e545d143ae8634865ecc78d4f1772cf4887ad3fa4e44bbf39d70322a201a80fc37c67bb34e7d77 buf/validate/conformance/cases/predefined_rules_proto_editions.proto +shake256:2ea0711cfff906e1cfa3e7357ac31abeb7c24ab716bd9f1aae55b650ba4e1327bcb8dd93bf5179303f3a2a995137fadf81098f9538f42a3974ce971a4797e3d1 buf/validate/conformance/cases/repeated.proto +shake256:c52e29912f8335b7318194fcc214b6b129e7b059cef19261857d83ffd7b2168739cfba67ce8ce774f2f96242c4098cd9d0304864c500498ea735f60496d04a9f buf/validate/conformance/cases/required_field_proto2.proto +shake256:e5d32ac0c0f9c64c783394e73b57f771b1cb637451575e006d324fba3d45ade5f072b111aeef260c07d17ce5390c1d5355ea79443e41dc26af0a51496e30b6ba buf/validate/conformance/cases/required_field_proto3.proto +shake256:e04bde1938bc544bdfa90ce41138fb9af0272c362898baf0c1e3db3f6c80fa9c75a83b546861deff98bd8fa489f1231da4e02b46937168f847be98b58bdc3240 buf/validate/conformance/cases/required_field_proto_editions.proto +shake256:f2a90e1e43ef0f221fff308ae337ba6bd666689a7c277b7c636f3c04d587c3f59a2be9456505c39e10a971868c20bbcad14f0be05a5385b5235204b9e88f67da buf/validate/conformance/cases/strings.proto +shake256:5bd92ab2145d3a6c301948b75af7b69d367f70b172fb29538d192c51e0516ee48d3db820a76f4ebcbbffc6ea1baf3b590399da2b160adb648458079080360b07 buf/validate/conformance/cases/subdirectory/in_subdirectory.proto +shake256:a742e6490da44a38f9977f2fabd38d92696dd8316720d9d8cd4d7adb2bcc09cc433dffa56112c569995e65649275bbc1a6e32c09a4cdfcce47a4c71371abb88d buf/validate/conformance/cases/wkt_any.proto +shake256:d6933c869e2bbb0fa1845a2ea4877d797857be804710a1b02a2989fc07d9655762312442112f207d86eb5e784200ba05b648386ad759452b04f60887de647867 buf/validate/conformance/cases/wkt_duration.proto +shake256:e0fa2c82ea25392f2e28d3345e1a7210c9fb82367795cbe2d5c191fa643171efec2d3b9752214d97fc936194428bf7d37fc365eadd0ecb369e888984902264cf buf/validate/conformance/cases/wkt_nested.proto +shake256:9d2d7856a4444798802bd7c45ff53f0f240f860fcaa23a5589ea9b3382d8467e4ca24d8fac61513e1a8e5fc7e0caa94c4f32c8dad00919cc5e1715a2b85e9a5d buf/validate/conformance/cases/wkt_timestamp.proto +shake256:7a4f30de82964fa0a8524111af262f3973d77cab6deb7c46c3880008109983c31ea1bff52fd9d2edecc4dddc8fff427713fc974def5b35155d9a728398c14f4b buf/validate/conformance/cases/wkt_wrappers.proto +shake256:5ed1054c3b0604ddb721929f2f9e0acc882f9d838a1f7e1e8312ebfe51b9a80e7937654f668e0a3b783340e64c331f540cf496f93ffd83f53dbdbcb14f9d9efa buf/validate/conformance/cases/yet_another_package/embed2.proto +shake256:79e93df83102a1a220d7c9e56a2f7fcc276b03b6ca7bced951965ce5d6060daaa77c04ca5a75fe53b14125c846dadd05808679fdc000e20f20b8a1620eadac4b buf/validate/conformance/harness/harness.proto +shake256:160efbb6958bcedfbf354970512f2485182bcb58b4c2bbdf2dc8798a79bc6c4ffe57c9c0cc6b52ac73c97a83c5c7550f5275f01d1bd44b127e3d4ab81ba23554 buf/validate/conformance/harness/results.proto diff --git a/modules/sync/bufbuild/protovalidate-testing/cas/1a324ec70b9778966d351c543c70f73ad942c82ea3c8ed24ec10f26ff6d4676f440f68a4c49d5be1b16cbd2b78dd89be559109866853742cf607619fe1672563 b/modules/sync/bufbuild/protovalidate-testing/cas/1a324ec70b9778966d351c543c70f73ad942c82ea3c8ed24ec10f26ff6d4676f440f68a4c49d5be1b16cbd2b78dd89be559109866853742cf607619fe1672563 new file mode 100644 index 00000000..12334645 --- /dev/null +++ b/modules/sync/bufbuild/protovalidate-testing/cas/1a324ec70b9778966d351c543c70f73ad942c82ea3c8ed24ec10f26ff6d4676f440f68a4c49d5be1b16cbd2b78dd89be559109866853742cf607619fe1672563 @@ -0,0 +1,361 @@ +// Copyright 2023 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto2"; + +package buf.validate.conformance.cases; + +import "buf/validate/validate.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +extend buf.validate.FloatRules { + optional float float_abs_range_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "float.abs_range.proto2" + expression: "this >= -rule && this <= rule" + message: "float value is out of range" + }]; +} + +extend buf.validate.DoubleRules { + optional double double_abs_range_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "double.abs_range.proto2" + expression: "this >= -rule && this <= rule" + message: "double value is out of range" + }]; +} + +extend buf.validate.Int32Rules { + repeated int32 int32_abs_in_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "int32.abs_in.proto2" + expression: "this in rule || this in rule.map(n, -n)" + message: "value must be in absolute value of list" + }]; +} + +extend buf.validate.Int64Rules { + repeated google.protobuf.Int64Value int64_abs_in_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "int64.abs_in.proto2" + expression: "this in rule || this in rule.map(n, -n)" + message: "value must be in absolute value of list" + }]; +} + +extend buf.validate.UInt32Rules { + optional bool uint32_even_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "uint32.even.proto2" + expression: "this % 2u == 0u" + message: "uint32 value is not even" + }]; +} + +extend buf.validate.UInt64Rules { + optional bool uint64_even_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "uint64.even.proto2" + expression: "this % 2u == 0u" + message: "uint64 value is not even" + }]; +} + +extend buf.validate.SInt32Rules { + optional bool sint32_even_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "sint32.even.proto2" + expression: "this % 2 == 0" + message: "sint32 value is not even" + }]; +} + +extend buf.validate.SInt64Rules { + optional bool sint64_even_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "sint64.even.proto2" + expression: "this % 2 == 0" + message: "sint64 value is not even" + }]; +} + +extend buf.validate.Fixed32Rules { + optional bool fixed32_even_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "fixed32.even.proto2" + expression: "this % 2u == 0u" + message: "fixed32 value is not even" + }]; +} + +extend buf.validate.Fixed64Rules { + optional bool fixed64_even_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "fixed64.even.proto2" + expression: "this % 2u == 0u" + message: "fixed64 value is not even" + }]; +} + +extend buf.validate.SFixed32Rules { + optional bool sfixed32_even_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "sfixed32.even.proto2" + expression: "this % 2 == 0" + message: "sfixed32 value is not even" + }]; +} + +extend buf.validate.SFixed64Rules { + optional bool sfixed64_even_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "sfixed64.even.proto2" + expression: "this % 2 == 0" + message: "sfixed64 value is not even" + }]; +} + +extend buf.validate.BoolRules { + optional bool bool_false_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "bool.false.proto2" + expression: "this == false" + message: "bool value is not false" + }]; +} + +extend buf.validate.StringRules { + optional bool string_valid_path_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "string.valid_path.proto2" + expression: "!this.matches('^([^/.][^/]?|[^/][^/.]|[^/]{3,})(/([^/.][^/]?|[^/][^/.]|[^/]{3,}))*$') ? 'not a valid path: `%s`'.format([this]) : ''" + }]; +} + +extend buf.validate.BytesRules { + optional bool bytes_valid_path_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "bytes.valid_path.proto2" + expression: "!string(this).matches('^([^/.][^/]?|[^/][^/.]|[^/]{3,})(/([^/.][^/]?|[^/][^/.]|[^/]{3,}))*$') ? 'not a valid path: `%s`'.format([this]) : ''" + }]; +} + +extend buf.validate.EnumRules { + optional bool enum_non_zero_proto2 = 1161 [(buf.validate.predefined).cel = { + id: "enum.non_zero.proto2" + expression: "int(this) != 0" + message: "enum value is not non-zero" + }]; +} + +extend buf.validate.RepeatedRules { + optional bool repeated_at_least_five_proto2 = 1161 [(predefined).cel = { + id: "repeated.at_least_five.proto2" + expression: "uint(this.size()) >= 5u" + message: "repeated field must have at least five values" + }]; +} + +extend buf.validate.DurationRules { + optional bool duration_too_long_proto2 = 1161 [(predefined).cel = { + id: "duration.too_long.proto2" + expression: "this <= duration('10s')" + message: "duration can't be longer than 10 seconds" + }]; +} + +extend buf.validate.TimestampRules { + optional bool timestamp_in_range_proto2 = 1161 [(predefined).cel = { + id: "timestamp.time_range.proto2" + expression: "int(this) >= 1049587200 && int(this) <= 1080432000" + message: "timestamp out of range" + }]; +} + +message PredefinedFloatRuleProto2 { + optional float val = 1 [(buf.validate.field).float.(float_abs_range_proto2) = 1.0]; +} + +message PredefinedDoubleRuleProto2 { + optional double val = 1 [(buf.validate.field).double.(double_abs_range_proto2) = 1.0]; +} + +message PredefinedInt32RuleProto2 { + optional int32 val = 1 [(buf.validate.field).int32.(int32_abs_in_proto2) = -2]; +} + +message PredefinedInt64RuleProto2 { + optional int64 val = 1 [(buf.validate.field).int64.(int64_abs_in_proto2) = {value: -2}]; +} + +message PredefinedUInt32RuleProto2 { + optional uint32 val = 1 [(buf.validate.field).uint32.(uint32_even_proto2) = true]; +} + +message PredefinedUInt64RuleProto2 { + optional uint64 val = 1 [(buf.validate.field).uint64.(uint64_even_proto2) = true]; +} + +message PredefinedSInt32RuleProto2 { + optional sint32 val = 1 [(buf.validate.field).sint32.(sint32_even_proto2) = true]; +} + +message PredefinedSInt64RuleProto2 { + optional sint64 val = 1 [(buf.validate.field).sint64.(sint64_even_proto2) = true]; +} + +message PredefinedFixed32RuleProto2 { + optional fixed32 val = 1 [(buf.validate.field).fixed32.(fixed32_even_proto2) = true]; +} + +message PredefinedFixed64RuleProto2 { + optional fixed64 val = 1 [(buf.validate.field).fixed64.(fixed64_even_proto2) = true]; +} + +message PredefinedSFixed32RuleProto2 { + optional sfixed32 val = 1 [(buf.validate.field).sfixed32.(sfixed32_even_proto2) = true]; +} + +message PredefinedSFixed64RuleProto2 { + optional sfixed64 val = 1 [(buf.validate.field).sfixed64.(sfixed64_even_proto2) = true]; +} + +message PredefinedBoolRuleProto2 { + optional bool val = 1 [(buf.validate.field).bool.(bool_false_proto2) = true]; +} + +message PredefinedStringRuleProto2 { + optional string val = 1 [(buf.validate.field).string.(string_valid_path_proto2) = true]; +} + +message PredefinedBytesRuleProto2 { + optional bytes val = 1 [(buf.validate.field).bytes.(bytes_valid_path_proto2) = true]; +} + +message PredefinedEnumRuleProto2 { + enum EnumProto2 { + ENUM_PROTO2_ZERO_UNSPECIFIED = 0; + ENUM_PROTO2_ONE = 1; + } + optional EnumProto2 val = 1 [(buf.validate.field).enum.(enum_non_zero_proto2) = true]; +} + +message PredefinedRepeatedRuleProto2 { + repeated uint64 val = 1 [(buf.validate.field).repeated.(repeated_at_least_five_proto2) = true]; +} + +message PredefinedDurationRuleProto2 { + optional google.protobuf.Duration val = 1 [(buf.validate.field).duration.(duration_too_long_proto2) = true]; +} + +message PredefinedTimestampRuleProto2 { + optional google.protobuf.Timestamp val = 1 [(buf.validate.field).timestamp.(timestamp_in_range_proto2) = true]; +} + +message PredefinedWrappedFloatRuleProto2 { + optional google.protobuf.FloatValue val = 1 [(buf.validate.field).float.(float_abs_range_proto2) = 1.0]; +} + +message PredefinedWrappedDoubleRuleProto2 { + optional google.protobuf.DoubleValue val = 1 [(buf.validate.field).double.(double_abs_range_proto2) = 1.0]; +} + +message PredefinedWrappedInt32RuleProto2 { + optional google.protobuf.Int32Value val = 1 [(buf.validate.field).int32.(int32_abs_in_proto2) = -2]; +} + +message PredefinedWrappedInt64RuleProto2 { + optional google.protobuf.Int64Value val = 1 [(buf.validate.field).int64.(int64_abs_in_proto2) = {value: -2}]; +} + +message PredefinedWrappedUInt32RuleProto2 { + optional google.protobuf.UInt32Value val = 1 [(buf.validate.field).uint32.(uint32_even_proto2) = true]; +} + +message PredefinedWrappedUInt64RuleProto2 { + optional google.protobuf.UInt64Value val = 1 [(buf.validate.field).uint64.(uint64_even_proto2) = true]; +} + +message PredefinedWrappedBoolRuleProto2 { + optional google.protobuf.BoolValue val = 1 [(buf.validate.field).bool.(bool_false_proto2) = true]; +} + +message PredefinedWrappedStringRuleProto2 { + optional google.protobuf.StringValue val = 1 [(buf.validate.field).string.(string_valid_path_proto2) = true]; +} + +message PredefinedWrappedBytesRuleProto2 { + optional google.protobuf.BytesValue val = 1 [(buf.validate.field).bytes.(bytes_valid_path_proto2) = true]; +} + +message PredefinedRepeatedWrappedFloatRuleProto2 { + repeated google.protobuf.FloatValue val = 1 [(buf.validate.field).repeated.items.float.(float_abs_range_proto2) = 1.0]; +} + +message PredefinedRepeatedWrappedDoubleRuleProto2 { + repeated google.protobuf.DoubleValue val = 1 [(buf.validate.field).repeated.items.double.(double_abs_range_proto2) = 1.0]; +} + +message PredefinedRepeatedWrappedInt32RuleProto2 { + repeated google.protobuf.Int32Value val = 1 [(buf.validate.field).repeated.items.int32.(int32_abs_in_proto2) = -2]; +} + +message PredefinedRepeatedWrappedInt64RuleProto2 { + repeated google.protobuf.Int64Value val = 1 [(buf.validate.field).repeated.items.int64.(int64_abs_in_proto2) = {value: -2}]; +} + +message PredefinedRepeatedWrappedUInt32RuleProto2 { + repeated google.protobuf.UInt32Value val = 1 [(buf.validate.field).repeated.items.uint32.(uint32_even_proto2) = true]; +} + +message PredefinedRepeatedWrappedUInt64RuleProto2 { + repeated google.protobuf.UInt64Value val = 1 [(buf.validate.field).repeated.items.uint64.(uint64_even_proto2) = true]; +} + +message PredefinedRepeatedWrappedBoolRuleProto2 { + repeated google.protobuf.BoolValue val = 1 [(buf.validate.field).repeated.items.bool.(bool_false_proto2) = true]; +} + +message PredefinedRepeatedWrappedStringRuleProto2 { + repeated google.protobuf.StringValue val = 1 [(buf.validate.field).repeated.items.string.(string_valid_path_proto2) = true]; +} + +message PredefinedRepeatedWrappedBytesRuleProto2 { + repeated google.protobuf.BytesValue val = 1 [(buf.validate.field).repeated.items.bytes.(bytes_valid_path_proto2) = true]; +} + +message PredefinedAndCustomRuleProto2 { + optional sint32 a = 1 [ + (field).cel = { + id: "predefined_and_custom_rule_scalar_proto2" + expression: "this > 24 ? '' : 'a must be greater than 24'" + }, + (field).sint32.(sint32_even_proto2) = true + ]; + + optional Nested b = 2 [(field).cel = { + id: "predefined_and_custom_rule_embedded_proto2" + message: "b.c must be a multiple of 3" + expression: "this.c % 3 == 0" + }]; + + message Nested { + optional sint32 c = 1 [ + (field).cel = { + id: "predefined_and_custom_rule_nested_proto2" + expression: "this > 0 ? '' : 'c must be positive'" + }, + (field).sint32.(sint32_even_proto2) = true + ]; + } +} + +message StandardPredefinedAndCustomRuleProto2 { + optional sint32 a = 1 [ + (field).sint32.lt = 28, + (field).sint32.(sint32_even_proto2) = true, + (field).cel = { + id: "standard_predefined_and_custom_rule_scalar_proto2" + expression: "this > 24 ? '' : 'a must be greater than 24'" + } + ]; +} diff --git a/modules/sync/bufbuild/protovalidate-testing/cas/52e8ba9cc75e6d9bbb6f48260eac0aa081732f3a8465e906d7be70a55c3dcbe6912b6e05ee9b2f961c415463b42cf9c558955611f440e4901b3c26bda89b99ab b/modules/sync/bufbuild/protovalidate-testing/cas/52e8ba9cc75e6d9bbb6f48260eac0aa081732f3a8465e906d7be70a55c3dcbe6912b6e05ee9b2f961c415463b42cf9c558955611f440e4901b3c26bda89b99ab new file mode 100644 index 00000000..d399bf9e --- /dev/null +++ b/modules/sync/bufbuild/protovalidate-testing/cas/52e8ba9cc75e6d9bbb6f48260eac0aa081732f3a8465e906d7be70a55c3dcbe6912b6e05ee9b2f961c415463b42cf9c558955611f440e4901b3c26bda89b99ab @@ -0,0 +1,224 @@ +// Copyright 2023 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package buf.validate.conformance.cases; + +import "buf/validate/conformance/cases/predefined_rules_proto2.proto"; +import "buf/validate/conformance/cases/predefined_rules_proto_editions.proto"; +import "buf/validate/validate.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +message PredefinedFloatRuleProto3 { + float val = 1 [(buf.validate.field).float.(float_abs_range_proto2) = 1.0]; +} + +message PredefinedDoubleRuleProto3 { + double val = 1 [(buf.validate.field).double.(double_abs_range_proto2) = 1.0]; +} + +message PredefinedInt32RuleProto3 { + int32 val = 1 [(buf.validate.field).int32.(int32_abs_in_proto2) = -2]; +} + +message PredefinedInt64RuleProto3 { + int64 val = 1 [(buf.validate.field).int64.(int64_abs_in_edition_2023) = {value: -2}]; +} + +message PredefinedUInt32RuleProto3 { + uint32 val = 1 [(buf.validate.field).uint32.(uint32_even_proto2) = true]; +} + +message PredefinedUInt64RuleProto3 { + uint64 val = 1 [(buf.validate.field).uint64.(uint64_even_proto2) = true]; +} + +message PredefinedSInt32RuleProto3 { + sint32 val = 1 [(buf.validate.field).sint32.(sint32_even_proto2) = true]; +} + +message PredefinedSInt64RuleProto3 { + sint64 val = 1 [(buf.validate.field).sint64.(sint64_even_proto2) = true]; +} + +message PredefinedFixed32RuleProto3 { + fixed32 val = 1 [(buf.validate.field).fixed32.(fixed32_even_proto2) = true]; +} + +message PredefinedFixed64RuleProto3 { + fixed64 val = 1 [(buf.validate.field).fixed64.(fixed64_even_proto2) = true]; +} + +message PredefinedSFixed32RuleProto3 { + sfixed32 val = 1 [(buf.validate.field).sfixed32.(sfixed32_even_proto2) = true]; +} + +message PredefinedSFixed64RuleProto3 { + sfixed64 val = 1 [(buf.validate.field).sfixed64.(sfixed64_even_proto2) = true]; +} + +message PredefinedBoolRuleProto3 { + bool val = 1 [(buf.validate.field).bool.(bool_false_proto2) = true]; +} + +message PredefinedStringRuleProto3 { + string val = 1 [(buf.validate.field).string.(string_valid_path_proto2) = true]; +} + +message PredefinedBytesRuleProto3 { + bytes val = 1 [(buf.validate.field).bytes.(bytes_valid_path_proto2) = true]; +} + +message PredefinedEnumRuleProto3 { + enum EnumProto3 { + ENUM_PROTO3_ZERO_UNSPECIFIED = 0; + ENUM_PROTO3_ONE = 1; + } + EnumProto3 val = 1 [(buf.validate.field).enum.(enum_non_zero_proto2) = true]; +} + +message PredefinedMapRuleProto3 { + map val = 1 [(buf.validate.field).map.(map_at_least_five_edition_2023) = true]; +} + +message PredefinedRepeatedRuleProto3 { + repeated uint64 val = 1 [(buf.validate.field).repeated.(repeated_at_least_five_proto2) = true]; +} + +message PredefinedDurationRuleProto3 { + google.protobuf.Duration val = 1 [(buf.validate.field).duration.(duration_too_long_proto2) = true]; +} + +message PredefinedTimestampRuleProto3 { + google.protobuf.Timestamp val = 1 [(buf.validate.field).timestamp.(timestamp_in_range_proto2) = true]; +} + +message PredefinedWrappedFloatRuleProto3 { + google.protobuf.FloatValue val = 1 [(buf.validate.field).float.(float_abs_range_proto2) = 1.0]; +} + +message PredefinedWrappedDoubleRuleProto3 { + google.protobuf.DoubleValue val = 1 [(buf.validate.field).double.(double_abs_range_proto2) = 1.0]; +} + +message PredefinedWrappedInt32RuleProto3 { + google.protobuf.Int32Value val = 1 [(buf.validate.field).int32.(int32_abs_in_proto2) = -2]; +} + +message PredefinedWrappedInt64RuleProto3 { + google.protobuf.Int64Value val = 1 [(buf.validate.field).int64.(int64_abs_in_proto2) = {value: -2}]; +} + +message PredefinedWrappedUInt32RuleProto3 { + google.protobuf.UInt32Value val = 1 [(buf.validate.field).uint32.(uint32_even_proto2) = true]; +} + +message PredefinedWrappedUInt64RuleProto3 { + google.protobuf.UInt64Value val = 1 [(buf.validate.field).uint64.(uint64_even_proto2) = true]; +} + +message PredefinedWrappedBoolRuleProto3 { + google.protobuf.BoolValue val = 1 [(buf.validate.field).bool.(bool_false_proto2) = true]; +} + +message PredefinedWrappedStringRuleProto3 { + google.protobuf.StringValue val = 1 [(buf.validate.field).string.(string_valid_path_proto2) = true]; +} + +message PredefinedWrappedBytesRuleProto3 { + google.protobuf.BytesValue val = 1 [(buf.validate.field).bytes.(bytes_valid_path_proto2) = true]; +} + +message PredefinedRepeatedWrappedFloatRuleProto3 { + repeated google.protobuf.FloatValue val = 1 [(buf.validate.field).repeated.items.float.(float_abs_range_proto2) = 1.0]; +} + +message PredefinedRepeatedWrappedDoubleRuleProto3 { + repeated google.protobuf.DoubleValue val = 1 [(buf.validate.field).repeated.items.double.(double_abs_range_proto2) = 1.0]; +} + +message PredefinedRepeatedWrappedInt32RuleProto3 { + repeated google.protobuf.Int32Value val = 1 [(buf.validate.field).repeated.items.int32.(int32_abs_in_proto2) = -2]; +} + +message PredefinedRepeatedWrappedInt64RuleProto3 { + repeated google.protobuf.Int64Value val = 1 [(buf.validate.field).repeated.items.int64.(int64_abs_in_proto2) = {value: -2}]; +} + +message PredefinedRepeatedWrappedUInt32RuleProto3 { + repeated google.protobuf.UInt32Value val = 1 [(buf.validate.field).repeated.items.uint32.(uint32_even_proto2) = true]; +} + +message PredefinedRepeatedWrappedUInt64RuleProto3 { + repeated google.protobuf.UInt64Value val = 1 [(buf.validate.field).repeated.items.uint64.(uint64_even_proto2) = true]; +} + +message PredefinedRepeatedWrappedBoolRuleProto3 { + repeated google.protobuf.BoolValue val = 1 [(buf.validate.field).repeated.items.bool.(bool_false_proto2) = true]; +} + +message PredefinedRepeatedWrappedStringRuleProto3 { + repeated google.protobuf.StringValue val = 1 [(buf.validate.field).repeated.items.string.(string_valid_path_proto2) = true]; +} + +message PredefinedRepeatedWrappedBytesRuleProto3 { + repeated google.protobuf.BytesValue val = 1 [(buf.validate.field).repeated.items.bytes.(bytes_valid_path_proto2) = true]; +} + +message PredefinedAndCustomRuleProto3 { + sint32 a = 1 [ + (field).cel = { + id: "predefined_and_custom_rule_scalar_proto3" + expression: "this > 24 ? '' : 'a must be greater than 24'" + }, + (field).sint32.(sint32_even_edition_2023) = true + ]; + + optional Nested b = 2 [(field).cel = { + id: "predefined_and_custom_rule_embedded_proto3" + message: "b.c must be a multiple of 3" + expression: "this.c % 3 == 0" + }]; + + message Nested { + sint32 c = 1 [ + (field).cel = { + id: "predefined_and_custom_rule_nested_proto3" + expression: "this > 0 ? '' : 'c must be positive'" + }, + (field).sint32.(sint32_even_edition_2023) = true + ]; + } +} + +message StandardPredefinedAndCustomRuleProto3 { + sint32 a = 1 [ + (field).sint32.lt = 28, + (field).sint32.(sint32_even_proto2) = true, + (field).cel = { + id: "standard_predefined_and_custom_rule_scalar_proto3" + expression: "this > 24 ? '' : 'a must be greater than 24'" + } + ]; +} + +// This is a workaround for https://github.com/bufbuild/buf/issues/3306. +// TODO(jchadwick-buf): Remove this when bufbuild/buf#3306 is fixed. +message PredefinedRulesProto3UnusedImportBugWorkaround { + StandardPredefinedAndCustomRuleProto2 dummy_1 = 1; + StandardPredefinedAndCustomRuleEdition2023 dummy_2 = 2; +} diff --git a/modules/sync/bufbuild/protovalidate-testing/cas/90c883c4a724a8634456bc03bdad9da5e45fd4741afb50d795e545d143ae8634865ecc78d4f1772cf4887ad3fa4e44bbf39d70322a201a80fc37c67bb34e7d77 b/modules/sync/bufbuild/protovalidate-testing/cas/90c883c4a724a8634456bc03bdad9da5e45fd4741afb50d795e545d143ae8634865ecc78d4f1772cf4887ad3fa4e44bbf39d70322a201a80fc37c67bb34e7d77 new file mode 100644 index 00000000..7a2acbdc --- /dev/null +++ b/modules/sync/bufbuild/protovalidate-testing/cas/90c883c4a724a8634456bc03bdad9da5e45fd4741afb50d795e545d143ae8634865ecc78d4f1772cf4887ad3fa4e44bbf39d70322a201a80fc37c67bb34e7d77 @@ -0,0 +1,373 @@ +// Copyright 2023 Buf Technologies, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +edition = "2023"; + +package buf.validate.conformance.cases; + +import "buf/validate/validate.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +extend buf.validate.FloatRules { + float float_abs_range_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "float.abs_range.edition_2023" + expression: "this >= -rule && this <= rule" + message: "float value is out of range" + }]; +} + +extend buf.validate.DoubleRules { + double double_abs_range_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "double.abs_range.edition_2023" + expression: "this >= -rule && this <= rule" + message: "double value is out of range" + }]; +} + +extend buf.validate.Int32Rules { + repeated int32 int32_abs_in_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "int32.abs_in.edition_2023" + expression: "this in rule || this in rule.map(n, -n)" + message: "value must be in absolute value of list" + }]; +} + +extend buf.validate.Int64Rules { + repeated google.protobuf.Int64Value int64_abs_in_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "int64.abs_in.edition_2023" + expression: "this in rule || this in rule.map(n, -n)" + message: "value must be in absolute value of list" + }]; +} + +extend buf.validate.UInt32Rules { + bool uint32_even_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "uint32.even.edition_2023" + expression: "this % 2u == 0u" + message: "uint32 value is not even" + }]; +} + +extend buf.validate.UInt64Rules { + bool uint64_even_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "uint64.even.edition_2023" + expression: "this % 2u == 0u" + message: "uint64 value is not even" + }]; +} + +extend buf.validate.SInt32Rules { + bool sint32_even_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "sint32.even.edition_2023" + expression: "this % 2 == 0" + message: "sint32 value is not even" + }]; +} + +extend buf.validate.SInt64Rules { + bool sint64_even_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "sint64.even.edition_2023" + expression: "this % 2 == 0" + message: "sint64 value is not even" + }]; +} + +extend buf.validate.Fixed32Rules { + bool fixed32_even_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "fixed32.even.edition_2023" + expression: "this % 2u == 0u" + message: "fixed32 value is not even" + }]; +} + +extend buf.validate.Fixed64Rules { + bool fixed64_even_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "fixed64.even.edition_2023" + expression: "this % 2u == 0u" + message: "fixed64 value is not even" + }]; +} + +extend buf.validate.SFixed32Rules { + bool sfixed32_even_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "sfixed32.even.edition_2023" + expression: "this % 2 == 0" + message: "sfixed32 value is not even" + }]; +} + +extend buf.validate.SFixed64Rules { + bool sfixed64_even_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "sfixed64.even.edition_2023" + expression: "this % 2 == 0" + message: "sfixed64 value is not even" + }]; +} + +extend buf.validate.BoolRules { + bool bool_false_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "bool.false.edition_2023" + expression: "this == false" + message: "bool value is not false" + }]; +} + +extend buf.validate.StringRules { + bool string_valid_path_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "string.valid_path.edition_2023" + expression: "!this.matches('^([^/.][^/]?|[^/][^/.]|[^/]{3,})(/([^/.][^/]?|[^/][^/.]|[^/]{3,}))*$') ? 'not a valid path: `%s`'.format([this]) : ''" + }]; +} + +extend buf.validate.BytesRules { + bool bytes_valid_path_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "bytes.valid_path.edition_2023" + expression: "!string(this).matches('^([^/.][^/]?|[^/][^/.]|[^/]{3,})(/([^/.][^/]?|[^/][^/.]|[^/]{3,}))*$') ? 'not a valid path: `%s`'.format([this]) : ''" + }]; +} + +extend buf.validate.EnumRules { + bool enum_non_zero_edition_2023 = 1162 [(buf.validate.predefined).cel = { + id: "enum.non_zero.edition_2023" + expression: "int(this) != 0" + message: "enum value is not non-zero" + }]; +} + +extend buf.validate.RepeatedRules { + bool repeated_at_least_five_edition_2023 = 1162 [(predefined).cel = { + id: "repeated.at_least_five.edition_2023" + expression: "uint(this.size()) >= 5u" + message: "repeated field must have at least five values" + }]; +} + +extend buf.validate.MapRules { + bool map_at_least_five_edition_2023 = 1162 [(predefined).cel = { + id: "map.at_least_five.edition_2023" + expression: "uint(this.size()) >= 5u" + message: "map must have at least five pairs" + }]; +} + +extend buf.validate.DurationRules { + bool duration_too_long_edition_2023 = 1162 [(predefined).cel = { + id: "duration.too_long.edition_2023" + expression: "this <= duration('10s')" + message: "duration can't be longer than 10 seconds" + }]; +} + +extend buf.validate.TimestampRules { + bool timestamp_in_range_edition_2023 = 1162 [(predefined).cel = { + id: "timestamp.time_range.edition_2023" + expression: "int(this) >= 1049587200 && int(this) <= 1080432000" + message: "timestamp out of range" + }]; +} + +message PredefinedFloatRuleEdition2023 { + float val = 1 [(buf.validate.field).float.(float_abs_range_edition_2023) = 1.0]; +} + +message PredefinedDoubleRuleEdition2023 { + double val = 1 [(buf.validate.field).double.(double_abs_range_edition_2023) = 1.0]; +} + +message PredefinedInt32RuleEdition2023 { + int32 val = 1 [(buf.validate.field).int32.(int32_abs_in_edition_2023) = -2]; +} + +message PredefinedInt64RuleEdition2023 { + int64 val = 1 [(buf.validate.field).int64.(int64_abs_in_edition_2023) = {value: -2}]; +} + +message PredefinedUInt32RuleEdition2023 { + uint32 val = 1 [(buf.validate.field).uint32.(uint32_even_edition_2023) = true]; +} + +message PredefinedUInt64RuleEdition2023 { + uint64 val = 1 [(buf.validate.field).uint64.(uint64_even_edition_2023) = true]; +} + +message PredefinedSInt32RuleEdition2023 { + sint32 val = 1 [(buf.validate.field).sint32.(sint32_even_edition_2023) = true]; +} + +message PredefinedSInt64RuleEdition2023 { + sint64 val = 1 [(buf.validate.field).sint64.(sint64_even_edition_2023) = true]; +} + +message PredefinedFixed32RuleEdition2023 { + fixed32 val = 1 [(buf.validate.field).fixed32.(fixed32_even_edition_2023) = true]; +} + +message PredefinedFixed64RuleEdition2023 { + fixed64 val = 1 [(buf.validate.field).fixed64.(fixed64_even_edition_2023) = true]; +} + +message PredefinedSFixed32RuleEdition2023 { + sfixed32 val = 1 [(buf.validate.field).sfixed32.(sfixed32_even_edition_2023) = true]; +} + +message PredefinedSFixed64RuleEdition2023 { + sfixed64 val = 1 [(buf.validate.field).sfixed64.(sfixed64_even_edition_2023) = true]; +} + +message PredefinedBoolRuleEdition2023 { + bool val = 1 [(buf.validate.field).bool.(bool_false_edition_2023) = true]; +} + +message PredefinedStringRuleEdition2023 { + string val = 1 [(buf.validate.field).string.(string_valid_path_edition_2023) = true]; +} + +message PredefinedBytesRuleEdition2023 { + bytes val = 1 [(buf.validate.field).bytes.(bytes_valid_path_edition_2023) = true]; +} + +message PredefinedEnumRuleEdition2023 { + enum EnumEdition2023 { + ENUM_EDITION2023_ZERO_UNSPECIFIED = 0; + ENUM_EDITION2023_ONE = 1; + } + EnumEdition2023 val = 1 [(buf.validate.field).enum.(enum_non_zero_edition_2023) = true]; +} + +message PredefinedRepeatedRuleEdition2023 { + repeated uint64 val = 1 [(buf.validate.field).repeated.(repeated_at_least_five_edition_2023) = true]; +} + +message PredefinedMapRuleEdition2023 { + map val = 1 [(buf.validate.field).map.(map_at_least_five_edition_2023) = true]; +} + +message PredefinedDurationRuleEdition2023 { + google.protobuf.Duration val = 1 [(buf.validate.field).duration.(duration_too_long_edition_2023) = true]; +} + +message PredefinedTimestampRuleEdition2023 { + google.protobuf.Timestamp val = 1 [(buf.validate.field).timestamp.(timestamp_in_range_edition_2023) = true]; +} + +message PredefinedWrappedFloatRuleEdition2023 { + google.protobuf.FloatValue val = 1 [(buf.validate.field).float.(float_abs_range_edition_2023) = 1.0]; +} + +message PredefinedWrappedDoubleRuleEdition2023 { + google.protobuf.DoubleValue val = 1 [(buf.validate.field).double.(double_abs_range_edition_2023) = 1.0]; +} + +message PredefinedWrappedInt32RuleEdition2023 { + google.protobuf.Int32Value val = 1 [(buf.validate.field).int32.(int32_abs_in_edition_2023) = -2]; +} + +message PredefinedWrappedInt64RuleEdition2023 { + google.protobuf.Int64Value val = 1 [(buf.validate.field).int64.(int64_abs_in_edition_2023) = {value: -2}]; +} + +message PredefinedWrappedUInt32RuleEdition2023 { + google.protobuf.UInt32Value val = 1 [(buf.validate.field).uint32.(uint32_even_edition_2023) = true]; +} + +message PredefinedWrappedUInt64RuleEdition2023 { + google.protobuf.UInt64Value val = 1 [(buf.validate.field).uint64.(uint64_even_edition_2023) = true]; +} + +message PredefinedWrappedBoolRuleEdition2023 { + google.protobuf.BoolValue val = 1 [(buf.validate.field).bool.(bool_false_edition_2023) = true]; +} + +message PredefinedWrappedStringRuleEdition2023 { + google.protobuf.StringValue val = 1 [(buf.validate.field).string.(string_valid_path_edition_2023) = true]; +} + +message PredefinedWrappedBytesRuleEdition2023 { + google.protobuf.BytesValue val = 1 [(buf.validate.field).bytes.(bytes_valid_path_edition_2023) = true]; +} + +message PredefinedRepeatedWrappedFloatRuleEdition2023 { + repeated google.protobuf.FloatValue val = 1 [(buf.validate.field).repeated.items.float.(float_abs_range_edition_2023) = 1.0]; +} + +message PredefinedRepeatedWrappedDoubleRuleEdition2023 { + repeated google.protobuf.DoubleValue val = 1 [(buf.validate.field).repeated.items.double.(double_abs_range_edition_2023) = 1.0]; +} + +message PredefinedRepeatedWrappedInt32RuleEdition2023 { + repeated google.protobuf.Int32Value val = 1 [(buf.validate.field).repeated.items.int32.(int32_abs_in_edition_2023) = -2]; +} + +message PredefinedRepeatedWrappedInt64RuleEdition2023 { + repeated google.protobuf.Int64Value val = 1 [(buf.validate.field).repeated.items.int64.(int64_abs_in_edition_2023) = {value: -2}]; +} + +message PredefinedRepeatedWrappedUInt32RuleEdition2023 { + repeated google.protobuf.UInt32Value val = 1 [(buf.validate.field).repeated.items.uint32.(uint32_even_edition_2023) = true]; +} + +message PredefinedRepeatedWrappedUInt64RuleEdition2023 { + repeated google.protobuf.UInt64Value val = 1 [(buf.validate.field).repeated.items.uint64.(uint64_even_edition_2023) = true]; +} + +message PredefinedRepeatedWrappedBoolRuleEdition2023 { + repeated google.protobuf.BoolValue val = 1 [(buf.validate.field).repeated.items.bool.(bool_false_edition_2023) = true]; +} + +message PredefinedRepeatedWrappedStringRuleEdition2023 { + repeated google.protobuf.StringValue val = 1 [(buf.validate.field).repeated.items.string.(string_valid_path_edition_2023) = true]; +} + +message PredefinedRepeatedWrappedBytesRuleEdition2023 { + repeated google.protobuf.BytesValue val = 1 [(buf.validate.field).repeated.items.bytes.(bytes_valid_path_edition_2023) = true]; +} + +message PredefinedAndCustomRuleEdition2023 { + sint32 a = 1 [ + (field).cel = { + id: "predefined_and_custom_rule_scalar_edition_2023" + expression: "this > 24 ? '' : 'a must be greater than 24'" + }, + (field).sint32.(sint32_even_edition_2023) = true + ]; + + Nested b = 2 [(field).cel = { + id: "predefined_and_custom_rule_embedded_edition_2023" + message: "b.c must be a multiple of 3" + expression: "this.c % 3 == 0" + }]; + + message Nested { + sint32 c = 1 [ + (field).cel = { + id: "predefined_and_custom_rule_nested_edition_2023" + expression: "this > 0 ? '' : 'c must be positive'" + }, + (field).sint32.(sint32_even_edition_2023) = true + ]; + } +} + +message StandardPredefinedAndCustomRuleEdition2023 { + sint32 a = 1 [ + (field).sint32.lt = 28, + (field).sint32.(sint32_even_edition_2023) = true, + (field).cel = { + id: "standard_predefined_and_custom_rule_scalar_edition_2023" + expression: "this > 24 ? '' : 'a must be greater than 24'" + } + ]; +} diff --git a/modules/sync/bufbuild/protovalidate-testing/state.json b/modules/sync/bufbuild/protovalidate-testing/state.json index 0131559b..25a42a53 100644 --- a/modules/sync/bufbuild/protovalidate-testing/state.json +++ b/modules/sync/bufbuild/protovalidate-testing/state.json @@ -175,6 +175,10 @@ { "name": "v0.8.1", "digest": "fdae90cc16aaa97f784fe72024fe03292761312d43177baac25fa04ea1be0bb1a44cc0959d22387e67ff64f2cdfccd4d2fdfd8cf142b2709a9ac2be0b6c10fda" + }, + { + "name": "v0.8.2", + "digest": "12504b9b4ef92597af595e1fafcdc1379fb1f25086c73b279538473fb81806c825c111270a553170140039fad44f7786bf040b3d54c954bfd7268fc19fa499ca" } ] } \ No newline at end of file diff --git a/modules/sync/bufbuild/protovalidate/state.json b/modules/sync/bufbuild/protovalidate/state.json index 9fc80bbe..b71e128a 100644 --- a/modules/sync/bufbuild/protovalidate/state.json +++ b/modules/sync/bufbuild/protovalidate/state.json @@ -179,6 +179,10 @@ { "name": "v0.8.1", "digest": "fed933fedf7f8b361baccfe560e76933b524d4f6cf25fc9652c94458be7b1c27abae5dab956031e1ba02a643feed2503afc1f1c513625ac107c151318ce2b2f6" + }, + { + "name": "v0.8.2", + "digest": "fed933fedf7f8b361baccfe560e76933b524d4f6cf25fc9652c94458be7b1c27abae5dab956031e1ba02a643feed2503afc1f1c513625ac107c151318ce2b2f6" } ] } \ No newline at end of file diff --git a/modules/sync/googleapis/googleapis/state.json b/modules/sync/googleapis/googleapis/state.json index 9b29eb2c..345335ef 100644 --- a/modules/sync/googleapis/googleapis/state.json +++ b/modules/sync/googleapis/googleapis/state.json @@ -14155,6 +14155,58 @@ { "name": "16a1580c06b3b32e8ab33c39d846bba7e21bfae3", "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "c472cf7c64e401e8f55353fddab1b5cd81efb607", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "3338937d03b7bf0ee0b5b4f58551280bd77359ec", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "e7fa33a66aa893b474af3b1a3a04192e47524559", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "917e347c536bec36446ac434455da0cb2e7ddf46", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "dd47718199b804d06f99aadc5287cacf638e2241", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "8d1759518953018930e6de2eac6fc579bb738869", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "4fe2139be5d934a40005c41b9dc132a143457ad0", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "475669fc7ac4b360159901fdafac4ffd06e7abd2", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "672cd6a381c7a0aea16438e2335dc7799bd70e4d", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "78d1fb208e4af3022a0aaf27bafa578ff326326e", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "3708fdf26f073ba5cb83c3f3a3778f701c80458d", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "ff4436beeb10715bedeb54da24f87a3b4dcddcea", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" + }, + { + "name": "b6a27d13a2f0223051ef720e4e9d0d52323560e6", + "digest": "e5e5f1c12f82e028ea696faa43b4f9dc6258a6d1226282962a8c8b282e10946281d815884f574bd279ebd9cd7588629beb3db17b892af6c33b56f92f8f67f509" } ] } \ No newline at end of file diff --git a/modules/sync/state.json b/modules/sync/state.json index e28e9bcd..447871fc 100644 --- a/modules/sync/state.json +++ b/modules/sync/state.json @@ -6,11 +6,11 @@ }, { "module_name": "bufbuild/protovalidate", - "latest_reference": "v0.8.1" + "latest_reference": "v0.8.2" }, { "module_name": "bufbuild/protovalidate-testing", - "latest_reference": "v0.8.1" + "latest_reference": "v0.8.2" }, { "module_name": "bufbuild/reflect", @@ -42,7 +42,7 @@ }, { "module_name": "googleapis/googleapis", - "latest_reference": "16a1580c06b3b32e8ab33c39d846bba7e21bfae3" + "latest_reference": "b6a27d13a2f0223051ef720e4e9d0d52323560e6" }, { "module_name": "googlechrome/lighthouse",