protovalidate 0.1.0.beta1

data/ext/protovalidate/sys/third_party/cel-cpp/internal/json.cc

@@ -0,0 +1,2041 @@
+// Copyright 2024 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#include "internal/json.h"
+
+#include <cmath>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#include "google/protobuf/duration.pb.h"
+#include "google/protobuf/struct.pb.h"
+#include "google/protobuf/timestamp.pb.h"
+#include "absl/base/attributes.h"
+#include "absl/base/no_destructor.h"
+#include "absl/base/nullability.h"
+#include "absl/base/optimization.h"
+#include "absl/functional/overload.h"
+#include "absl/log/absl_check.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
+#include "extensions/protobuf/internal/map_reflection.h"
+#include "internal/status_macros.h"
+#include "internal/strings.h"
+#include "internal/well_known_types.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/map_field.h"
+#include "google/protobuf/message.h"
+#include "google/protobuf/message_lite.h"
+#include "google/protobuf/util/time_util.h"
+
+#undef GetMessage
+
+namespace cel::internal {
+
+namespace {
+
+using ::cel::well_known_types::AsVariant;
+using ::cel::well_known_types::GetListValueReflection;
+using ::cel::well_known_types::GetRepeatedBytesField;
+using ::cel::well_known_types::GetRepeatedStringField;
+using ::cel::well_known_types::GetStructReflection;
+using ::cel::well_known_types::GetValueReflection;
+using ::cel::well_known_types::JsonReflection;
+using ::cel::well_known_types::ListValueReflection;
+using ::cel::well_known_types::Reflection;
+using ::cel::well_known_types::StructReflection;
+using ::cel::well_known_types::ValueReflection;
+using ::google::protobuf::Descriptor;
+using ::google::protobuf::FieldDescriptor;
+using ::google::protobuf::util::TimeUtil;
+
+// Yanked from the implementation `google::protobuf::util::TimeUtil`.
+template <typename Chars>
+absl::Status SnakeCaseToCamelCaseImpl(Chars input,
+                                      std::string* absl_nonnull output) {
+  output->clear();
+  bool after_underscore = false;
+  for (char input_char : input) {
+    if (absl::ascii_isupper(input_char)) {
+      // The field name must not contain uppercase letters.
+      return absl::InvalidArgumentError(
+          "field mask path name contains uppercase letters");
+    }
+    if (after_underscore) {
+      if (absl::ascii_islower(input_char)) {
+        output->push_back(absl::ascii_toupper(input_char));
+        after_underscore = false;
+      } else {
+        // The character after a "_" must be a lowercase letter.
+        return absl::InvalidArgumentError(
+            "field mask path contains '_' not followed by a lowercase letter");
+      }
+    } else if (input_char == '_') {
+      after_underscore = true;
+    } else {
+      output->push_back(input_char);
+    }
+  }
+  if (after_underscore) {
+    // Trailing "_".
+    return absl::InvalidArgumentError("field mask path contains trailing '_'");
+  }
+  return absl::OkStatus();
+}
+
+absl::Status SnakeCaseToCamelCase(const well_known_types::StringValue& input,
+                                  std::string* absl_nonnull output) {
+  return absl::visit(absl::Overload(
+                         [&](absl::string_view string) -> absl::Status {
+                           return SnakeCaseToCamelCaseImpl(string, output);
+                         },
+                         [&](const absl::Cord& cord) -> absl::Status {
+                           return SnakeCaseToCamelCaseImpl(cord.Chars(),
+                                                           output);
+                         }),
+                     AsVariant(input));
+}
+
+class MessageToJsonState;
+
+using MapFieldKeyToString = std::string (*)(const google::protobuf::MapKey&);
+
+std::string BoolMapFieldKeyToString(const google::protobuf::MapKey& key) {
+  return key.GetBoolValue() ? "true" : "false";
+}
+
+std::string Int32MapFieldKeyToString(const google::protobuf::MapKey& key) {
+  return absl::StrCat(key.GetInt32Value());
+}
+
+std::string Int64MapFieldKeyToString(const google::protobuf::MapKey& key) {
+  return absl::StrCat(key.GetInt64Value());
+}
+
+std::string UInt32MapFieldKeyToString(const google::protobuf::MapKey& key) {
+  return absl::StrCat(key.GetUInt32Value());
+}
+
+std::string UInt64MapFieldKeyToString(const google::protobuf::MapKey& key) {
+  return absl::StrCat(key.GetUInt64Value());
+}
+
+std::string StringMapFieldKeyToString(const google::protobuf::MapKey& key) {
+  return std::string(key.GetStringValue());
+}
+
+MapFieldKeyToString GetMapFieldKeyToString(
+    const google::protobuf::FieldDescriptor* absl_nonnull field) {
+  switch (field->cpp_type()) {
+    case FieldDescriptor::CPPTYPE_BOOL:
+      return &BoolMapFieldKeyToString;
+    case FieldDescriptor::CPPTYPE_INT32:
+      return &Int32MapFieldKeyToString;
+    case FieldDescriptor::CPPTYPE_INT64:
+      return &Int64MapFieldKeyToString;
+    case FieldDescriptor::CPPTYPE_UINT32:
+      return &UInt32MapFieldKeyToString;
+    case FieldDescriptor::CPPTYPE_UINT64:
+      return &UInt64MapFieldKeyToString;
+    case FieldDescriptor::CPPTYPE_STRING:
+      return &StringMapFieldKeyToString;
+    default:
+      ABSL_UNREACHABLE();
+  }
+}
+
+using MapFieldValueToValue = absl::Status (MessageToJsonState::*)(
+    const google::protobuf::MapValueConstRef& value,
+    const google::protobuf::FieldDescriptor* absl_nonnull field,
+    google::protobuf::MessageLite* absl_nonnull result);
+
+using RepeatedFieldToValue = absl::Status (MessageToJsonState::*)(
+    const google::protobuf::Reflection* absl_nonnull reflection,
+    const google::protobuf::Message& message,
+    const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+    google::protobuf::MessageLite* absl_nonnull result);
+
+class MessageToJsonState {
+ public:
+  MessageToJsonState(const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+                     google::protobuf::MessageFactory* absl_nonnull message_factory)
+      : descriptor_pool_(descriptor_pool), message_factory_(message_factory) {}
+
+  virtual ~MessageToJsonState() = default;
+
+  absl::Status ToJson(const google::protobuf::Message& message,
+                      google::protobuf::MessageLite* absl_nonnull result) {
+    const auto* descriptor = message.GetDescriptor();
+    switch (descriptor->well_known_type()) {
+      case Descriptor::WELLKNOWNTYPE_DOUBLEVALUE: {
+        CEL_RETURN_IF_ERROR(reflection_.DoubleValue().Initialize(descriptor));
+        SetNumberValue(result, reflection_.DoubleValue().GetValue(message));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_FLOATVALUE: {
+        CEL_RETURN_IF_ERROR(reflection_.FloatValue().Initialize(descriptor));
+        SetNumberValue(result, reflection_.FloatValue().GetValue(message));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_INT64VALUE: {
+        CEL_RETURN_IF_ERROR(reflection_.Int64Value().Initialize(descriptor));
+        SetNumberValue(result, reflection_.Int64Value().GetValue(message));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_UINT64VALUE: {
+        CEL_RETURN_IF_ERROR(reflection_.UInt64Value().Initialize(descriptor));
+        SetNumberValue(result, reflection_.UInt64Value().GetValue(message));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_INT32VALUE: {
+        CEL_RETURN_IF_ERROR(reflection_.Int32Value().Initialize(descriptor));
+        SetNumberValue(result, reflection_.Int32Value().GetValue(message));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_UINT32VALUE: {
+        CEL_RETURN_IF_ERROR(reflection_.UInt32Value().Initialize(descriptor));
+        SetNumberValue(result, reflection_.UInt32Value().GetValue(message));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_STRINGVALUE: {
+        CEL_RETURN_IF_ERROR(reflection_.StringValue().Initialize(descriptor));
+        StringValueToJson(reflection_.StringValue().GetValue(message, scratch_),
+                          result);
+      } break;
+      case Descriptor::WELLKNOWNTYPE_BYTESVALUE: {
+        CEL_RETURN_IF_ERROR(reflection_.BytesValue().Initialize(descriptor));
+        BytesValueToJson(reflection_.BytesValue().GetValue(message, scratch_),
+                         result);
+      } break;
+      case Descriptor::WELLKNOWNTYPE_BOOLVALUE: {
+        CEL_RETURN_IF_ERROR(reflection_.BoolValue().Initialize(descriptor));
+        SetBoolValue(result, reflection_.BoolValue().GetValue(message));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_ANY: {
+        CEL_ASSIGN_OR_RETURN(auto unpacked,
+                             well_known_types::UnpackAnyFrom(
+                                 result->GetArena(), reflection_.Any(), message,
+                                 descriptor_pool_, message_factory_));
+        auto* struct_result = MutableStructValue(result);
+        const auto* unpacked_descriptor = unpacked->GetDescriptor();
+        SetStringValue(InsertField(struct_result, "@type"),
+                       absl::StrCat("type.googleapis.com/",
+                                    unpacked_descriptor->full_name()));
+        switch (unpacked_descriptor->well_known_type()) {
+          case Descriptor::WELLKNOWNTYPE_DOUBLEVALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_FLOATVALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_INT64VALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_UINT64VALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_INT32VALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_UINT32VALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_STRINGVALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_BYTESVALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_BOOLVALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_FIELDMASK:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_DURATION:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_TIMESTAMP:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_VALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_LISTVALUE:
+            ABSL_FALLTHROUGH_INTENDED;
+          case Descriptor::WELLKNOWNTYPE_STRUCT:
+            return ToJson(*unpacked, InsertField(struct_result, "value"));
+          default:
+            if (unpacked_descriptor->full_name() == "google.protobuf.Empty") {
+              MutableStructValue(InsertField(struct_result, "value"));
+              return absl::OkStatus();
+            } else {
+              return MessageToJson(*unpacked, struct_result);
+            }
+        }
+      }
+      case Descriptor::WELLKNOWNTYPE_FIELDMASK: {
+        CEL_RETURN_IF_ERROR(reflection_.FieldMask().Initialize(descriptor));
+        std::vector<std::string> paths;
+        const int paths_size = reflection_.FieldMask().PathsSize(message);
+        for (int i = 0; i < paths_size; ++i) {
+          CEL_RETURN_IF_ERROR(SnakeCaseToCamelCase(
+              reflection_.FieldMask().Paths(message, i, scratch_),
+              &paths.emplace_back()));
+        }
+        SetStringValue(result, absl::StrJoin(paths, ","));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_DURATION: {
+        CEL_RETURN_IF_ERROR(reflection_.Duration().Initialize(descriptor));
+        google::protobuf::Duration duration;
+        duration.set_seconds(reflection_.Duration().GetSeconds(message));
+        duration.set_nanos(reflection_.Duration().GetNanos(message));
+        SetStringValue(result, TimeUtil::ToString(duration));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_TIMESTAMP: {
+        CEL_RETURN_IF_ERROR(reflection_.Timestamp().Initialize(descriptor));
+        google::protobuf::Timestamp timestamp;
+        timestamp.set_seconds(reflection_.Timestamp().GetSeconds(message));
+        timestamp.set_nanos(reflection_.Timestamp().GetNanos(message));
+        SetStringValue(result, TimeUtil::ToString(timestamp));
+      } break;
+      case Descriptor::WELLKNOWNTYPE_VALUE: {
+        absl::Cord serialized;
+        if (!message.SerializePartialToString(&serialized)) {
+          return absl::UnknownError(
+              "failed to serialize message google.protobuf.Value");
+        }
+        if (!result->ParsePartialFromString(serialized)) {
+          return absl::UnknownError(
+              "failed to parsed message: google.protobuf.Value");
+        }
+      } break;
+      case Descriptor::WELLKNOWNTYPE_LISTVALUE: {
+        absl::Cord serialized;
+        if (!message.SerializePartialToString(&serialized)) {
+          return absl::UnknownError(
+              "failed to serialize message google.protobuf.ListValue");
+        }
+        if (!MutableListValue(result)->ParsePartialFromString(serialized)) {
+          return absl::UnknownError(
+              "failed to parsed message: google.protobuf.ListValue");
+        }
+      } break;
+      case Descriptor::WELLKNOWNTYPE_STRUCT: {
+        absl::Cord serialized;
+        if (!message.SerializePartialToString(&serialized)) {
+          return absl::UnknownError(
+              "failed to serialize message google.protobuf.Struct");
+        }
+        if (!MutableStructValue(result)->ParsePartialFromString(serialized)) {
+          return absl::UnknownError(
+              "failed to parsed message: google.protobuf.Struct");
+        }
+      } break;
+      default:
+        return MessageToJson(message, MutableStructValue(result));
+    }
+    return absl::OkStatus();
+  }
+
+  absl::Status ToJsonObject(const google::protobuf::Message& message,
+                            google::protobuf::MessageLite* absl_nonnull result) {
+    return MessageToJson(message, result);
+  }
+
+  absl::Status FieldToJson(const google::protobuf::Message& message,
+                           const google::protobuf::FieldDescriptor* absl_nonnull field,
+                           google::protobuf::MessageLite* absl_nonnull result) {
+    return MessageFieldToJson(message, field, result);
+  }
+
+  absl::Status FieldToJsonArray(
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    return MessageRepeatedFieldToJson(message, field, result);
+  }
+
+  absl::Status FieldToJsonObject(
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    return MessageMapFieldToJson(message, field, result);
+  }
+
+  virtual absl::Status Initialize(
+      google::protobuf::MessageLite* absl_nonnull message) = 0;
+
+ private:
+  absl::StatusOr<MapFieldValueToValue> GetMapFieldValueToValue(
+      const google::protobuf::FieldDescriptor* absl_nonnull field) {
+    switch (field->type()) {
+      case FieldDescriptor::TYPE_DOUBLE:
+        return &MessageToJsonState::MapDoubleFieldToValue;
+      case FieldDescriptor::TYPE_FLOAT:
+        return &MessageToJsonState::MapFloatFieldToValue;
+      case FieldDescriptor::TYPE_FIXED64:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_UINT64:
+        return &MessageToJsonState::MapUInt64FieldToValue;
+      case FieldDescriptor::TYPE_BOOL:
+        return &MessageToJsonState::MapBoolFieldToValue;
+      case FieldDescriptor::TYPE_STRING:
+        return &MessageToJsonState::MapStringFieldToValue;
+      case FieldDescriptor::TYPE_GROUP:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_MESSAGE:
+        return &MessageToJsonState::MapMessageFieldToValue;
+      case FieldDescriptor::TYPE_BYTES:
+        return &MessageToJsonState::MapBytesFieldToValue;
+      case FieldDescriptor::TYPE_FIXED32:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_UINT32:
+        return &MessageToJsonState::MapUInt32FieldToValue;
+      case FieldDescriptor::TYPE_ENUM: {
+        const auto* enum_descriptor = field->enum_type();
+        if (enum_descriptor->full_name() == "google.protobuf.NullValue") {
+          return &MessageToJsonState::MapNullFieldToValue;
+        } else {
+          return &MessageToJsonState::MapEnumFieldToValue;
+        }
+      }
+      case FieldDescriptor::TYPE_SFIXED32:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_SINT32:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_INT32:
+        return &MessageToJsonState::MapInt32FieldToValue;
+      case FieldDescriptor::TYPE_SFIXED64:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_SINT64:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_INT64:
+        return &MessageToJsonState::MapInt64FieldToValue;
+      default:
+        return absl::InvalidArgumentError(absl::StrCat(
+            "unexpected message field type: ", field->type_name()));
+    }
+  }
+
+  absl::Status MapBoolFieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_BOOL);
+    SetBoolValue(result, value.GetBoolValue());
+    return absl::OkStatus();
+  }
+
+  absl::Status MapInt32FieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_INT32);
+    SetNumberValue(result, value.GetInt32Value());
+    return absl::OkStatus();
+  }
+
+  absl::Status MapInt64FieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_INT64);
+    SetNumberValue(result, value.GetInt64Value());
+    return absl::OkStatus();
+  }
+
+  absl::Status MapUInt32FieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_UINT32);
+    SetNumberValue(result, value.GetUInt32Value());
+    return absl::OkStatus();
+  }
+
+  absl::Status MapUInt64FieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_UINT64);
+    SetNumberValue(result, value.GetUInt64Value());
+    return absl::OkStatus();
+  }
+
+  absl::Status MapFloatFieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_FLOAT);
+    SetNumberValue(result, value.GetFloatValue());
+    return absl::OkStatus();
+  }
+
+  absl::Status MapDoubleFieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_DOUBLE);
+    SetNumberValue(result, value.GetDoubleValue());
+    return absl::OkStatus();
+  }
+
+  absl::Status MapBytesFieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_BYTES);
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_STRING);
+    SetStringValueFromBytes(result, value.GetStringValue());
+    return absl::OkStatus();
+  }
+
+  absl::Status MapStringFieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_STRING);
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_STRING);
+    SetStringValue(result, value.GetStringValue());
+    return absl::OkStatus();
+  }
+
+  absl::Status MapMessageFieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_MESSAGE);
+    return ToJson(value.GetMessageValue(), result);
+  }
+
+  absl::Status MapEnumFieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_ENUM);
+    ABSL_DCHECK_NE(field->enum_type()->full_name(),
+                   "google.protobuf.NullValue");
+    if (const auto* value_descriptor =
+            field->enum_type()->FindValueByNumber(value.GetEnumValue());
+        value_descriptor != nullptr) {
+      SetStringValue(result, value_descriptor->name());
+    } else {
+      SetNumberValue(result, value.GetEnumValue());
+    }
+    return absl::OkStatus();
+  }
+
+  absl::Status MapNullFieldToValue(
+      const google::protobuf::MapValueConstRef& value,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(value.type(), field->cpp_type());
+    ABSL_DCHECK(!field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_ENUM);
+    ABSL_DCHECK_EQ(field->enum_type()->full_name(),
+                   "google.protobuf.NullValue");
+    SetNullValue(result);
+    return absl::OkStatus();
+  }
+
+  absl::StatusOr<RepeatedFieldToValue> GetRepeatedFieldToValue(
+      const google::protobuf::FieldDescriptor* absl_nonnull field) {
+    switch (field->type()) {
+      case FieldDescriptor::TYPE_DOUBLE:
+        return &MessageToJsonState::RepeatedDoubleFieldToValue;
+      case FieldDescriptor::TYPE_FLOAT:
+        return &MessageToJsonState::RepeatedFloatFieldToValue;
+      case FieldDescriptor::TYPE_FIXED64:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_UINT64:
+        return &MessageToJsonState::RepeatedUInt64FieldToValue;
+      case FieldDescriptor::TYPE_BOOL:
+        return &MessageToJsonState::RepeatedBoolFieldToValue;
+      case FieldDescriptor::TYPE_STRING:
+        return &MessageToJsonState::RepeatedStringFieldToValue;
+      case FieldDescriptor::TYPE_GROUP:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_MESSAGE:
+        return &MessageToJsonState::RepeatedMessageFieldToValue;
+      case FieldDescriptor::TYPE_BYTES:
+        return &MessageToJsonState::RepeatedBytesFieldToValue;
+      case FieldDescriptor::TYPE_FIXED32:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_UINT32:
+        return &MessageToJsonState::RepeatedUInt32FieldToValue;
+      case FieldDescriptor::TYPE_ENUM: {
+        const auto* enum_descriptor = field->enum_type();
+        if (enum_descriptor->full_name() == "google.protobuf.NullValue") {
+          return &MessageToJsonState::RepeatedNullFieldToValue;
+        } else {
+          return &MessageToJsonState::RepeatedEnumFieldToValue;
+        }
+      }
+      case FieldDescriptor::TYPE_SFIXED32:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_SINT32:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_INT32:
+        return &MessageToJsonState::RepeatedInt32FieldToValue;
+      case FieldDescriptor::TYPE_SFIXED64:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_SINT64:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_INT64:
+        return &MessageToJsonState::RepeatedInt64FieldToValue;
+      default:
+        return absl::InvalidArgumentError(absl::StrCat(
+            "unexpected message field type: ", field->type_name()));
+    }
+  }
+
+  absl::Status RepeatedBoolFieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_BOOL);
+    SetBoolValue(result, reflection->GetRepeatedBool(message, field, index));
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedInt32FieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_INT32);
+    SetNumberValue(result, reflection->GetRepeatedInt32(message, field, index));
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedInt64FieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_INT64);
+    SetNumberValue(result, reflection->GetRepeatedInt64(message, field, index));
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedUInt32FieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_UINT32);
+    SetNumberValue(result,
+                   reflection->GetRepeatedUInt32(message, field, index));
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedUInt64FieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_UINT64);
+    SetNumberValue(result,
+                   reflection->GetRepeatedUInt64(message, field, index));
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedFloatFieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_FLOAT);
+    SetNumberValue(result, reflection->GetRepeatedFloat(message, field, index));
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedDoubleFieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_DOUBLE);
+    SetNumberValue(result,
+                   reflection->GetRepeatedDouble(message, field, index));
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedBytesFieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_BYTES);
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_STRING);
+    absl::visit(absl::Overload(
+                    [&](absl::string_view string) -> void {
+                      SetStringValueFromBytes(result, string);
+                    },
+                    [&](absl::Cord&& cord) -> void {
+                      SetStringValueFromBytes(result, cord);
+                    }),
+                AsVariant(GetRepeatedBytesField(reflection, message, field,
+                                                index, scratch_)));
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedStringFieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_STRING);
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_STRING);
+    absl::visit(
+        absl::Overload(
+            [&](absl::string_view string) -> void {
+              SetStringValue(result, string);
+            },
+            [&](absl::Cord&& cord) -> void { SetStringValue(result, cord); }),
+        AsVariant(GetRepeatedStringField(reflection, message, field, index,
+                                         scratch_)));
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedMessageFieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_MESSAGE);
+    return ToJson(reflection->GetRepeatedMessage(message, field, index),
+                  result);
+  }
+
+  absl::Status RepeatedEnumFieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_ENUM);
+    ABSL_DCHECK_NE(field->enum_type()->full_name(),
+                   "google.protobuf.NullValue");
+    if (const auto* value = reflection->GetRepeatedEnum(message, field, index);
+        value != nullptr) {
+      SetStringValue(result, value->name());
+    } else {
+      SetNumberValue(result,
+                     reflection->GetRepeatedEnumValue(message, field, index));
+    }
+    return absl::OkStatus();
+  }
+
+  absl::Status RepeatedNullFieldToValue(
+      const google::protobuf::Reflection* absl_nonnull reflection,
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field, int index,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    ABSL_DCHECK_EQ(reflection, message.GetReflection());
+    ABSL_DCHECK(!field->is_map() && field->is_repeated());
+    ABSL_DCHECK_EQ(field->cpp_type(), FieldDescriptor::CPPTYPE_ENUM);
+    ABSL_DCHECK_EQ(field->enum_type()->full_name(),
+                   "google.protobuf.NullValue");
+    SetNullValue(result);
+    return absl::OkStatus();
+  }
+
+  absl::Status MessageMapFieldToJson(
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    const auto* reflection = message.GetReflection();
+    if (reflection->FieldSize(message, field) == 0) {
+      return absl::OkStatus();
+    }
+    const auto key_to_string =
+        GetMapFieldKeyToString(field->message_type()->map_key());
+    const auto* value_descriptor = field->message_type()->map_value();
+    CEL_ASSIGN_OR_RETURN(const auto value_to_value,
+                         GetMapFieldValueToValue(value_descriptor));
+    auto begin = extensions::protobuf_internal::ConstMapBegin(*reflection,
+                                                              message, *field);
+    const auto end = extensions::protobuf_internal::ConstMapEnd(
+        *reflection, message, *field);
+    for (; begin != end; ++begin) {
+      auto key = (*key_to_string)(begin.GetKey());
+      CEL_RETURN_IF_ERROR((this->*value_to_value)(
+          begin.GetValueRef(), value_descriptor, InsertField(result, key)));
+    }
+    return absl::OkStatus();
+  }
+
+  absl::Status MessageRepeatedFieldToJson(
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    const auto* reflection = message.GetReflection();
+    const int size = reflection->FieldSize(message, field);
+    if (size == 0) {
+      return absl::OkStatus();
+    }
+    CEL_ASSIGN_OR_RETURN(const auto to_value, GetRepeatedFieldToValue(field));
+    for (int index = 0; index < size; ++index) {
+      CEL_RETURN_IF_ERROR((this->*to_value)(reflection, message, field, index,
+                                            AddValues(result)));
+    }
+    return absl::OkStatus();
+  }
+
+  absl::Status MessageFieldToJson(
+      const google::protobuf::Message& message,
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      google::protobuf::MessageLite* absl_nonnull result) {
+    if (field->is_map()) {
+      return MessageMapFieldToJson(message, field, MutableStructValue(result));
+    }
+    if (field->is_repeated()) {
+      return MessageRepeatedFieldToJson(message, field,
+                                        MutableListValue(result));
+    }
+    const auto* reflection = message.GetReflection();
+    switch (field->type()) {
+      case FieldDescriptor::TYPE_DOUBLE:
+        SetNumberValue(result, reflection->GetDouble(message, field));
+        break;
+      case FieldDescriptor::TYPE_FLOAT:
+        SetNumberValue(result, reflection->GetFloat(message, field));
+        break;
+      case FieldDescriptor::TYPE_FIXED64:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_UINT64:
+        SetNumberValue(result, reflection->GetUInt64(message, field));
+        break;
+      case FieldDescriptor::TYPE_BOOL:
+        SetBoolValue(result, reflection->GetBool(message, field));
+        break;
+      case FieldDescriptor::TYPE_STRING:
+        StringValueToJson(
+            well_known_types::GetStringField(message, field, scratch_), result);
+        break;
+      case FieldDescriptor::TYPE_GROUP:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_MESSAGE:
+        return ToJson((reflection->GetMessage)(message, field), result);
+      case FieldDescriptor::TYPE_BYTES:
+        BytesValueToJson(
+            well_known_types::GetBytesField(message, field, scratch_), result);
+        break;
+      case FieldDescriptor::TYPE_FIXED32:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_UINT32:
+        SetNumberValue(result, reflection->GetUInt32(message, field));
+        break;
+      case FieldDescriptor::TYPE_ENUM: {
+        const auto* enum_descriptor = field->enum_type();
+        if (enum_descriptor->full_name() == "google.protobuf.NullValue") {
+          SetNullValue(result);
+        } else {
+          const auto* enum_value_descriptor =
+              reflection->GetEnum(message, field);
+          if (enum_value_descriptor != nullptr) {
+            SetStringValue(result, enum_value_descriptor->name());
+          } else {
+            SetNumberValue(result, reflection->GetEnumValue(message, field));
+          }
+        }
+      } break;
+      case FieldDescriptor::TYPE_SFIXED32:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_SINT32:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_INT32:
+        SetNumberValue(result, reflection->GetInt32(message, field));
+        break;
+      case FieldDescriptor::TYPE_SFIXED64:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_SINT64:
+        ABSL_FALLTHROUGH_INTENDED;
+      case FieldDescriptor::TYPE_INT64:
+        SetNumberValue(result, reflection->GetInt64(message, field));
+        break;
+      default:
+        return absl::InvalidArgumentError(absl::StrCat(
+            "unexpected message field type: ", field->type_name()));
+    }
+    return absl::OkStatus();
+  }
+
+  absl::Status MessageToJson(const google::protobuf::Message& message,
+                             google::protobuf::MessageLite* absl_nonnull result) {
+    std::vector<const google::protobuf::FieldDescriptor*> fields;
+    const auto* reflection = message.GetReflection();
+    reflection->ListFields(message, &fields);
+    if (!fields.empty()) {
+      for (const auto* field : fields) {
+        CEL_RETURN_IF_ERROR(MessageFieldToJson(
+            message, field, InsertField(result, field->json_name())));
+      }
+    }
+    return absl::OkStatus();
+  }
+
+  void StringValueToJson(const well_known_types::StringValue& value,
+                         google::protobuf::MessageLite* absl_nonnull result) const {
+    absl::visit(absl::Overload([&](absl::string_view string)
+                                   -> void { SetStringValue(result, string); },
+                               [&](const absl::Cord& cord) -> void {
+                                 SetStringValue(result, cord);
+                               }),
+                AsVariant(value));
+  }
+
+  void BytesValueToJson(const well_known_types::BytesValue& value,
+                        google::protobuf::MessageLite* absl_nonnull result) const {
+    absl::visit(absl::Overload(
+                    [&](absl::string_view string) -> void {
+                      SetStringValueFromBytes(result, string);
+                    },
+                    [&](const absl::Cord& cord) -> void {
+                      SetStringValueFromBytes(result, cord);
+                    }),
+                AsVariant(value));
+  }
+
+  virtual void SetNullValue(
+      google::protobuf::MessageLite* absl_nonnull message) const = 0;
+
+  virtual void SetBoolValue(google::protobuf::MessageLite* absl_nonnull message,
+                            bool value) const = 0;
+
+  virtual void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                              double value) const = 0;
+
+  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                      float value) const {
+    SetNumberValue(message, static_cast<double>(value));
+  }
+
+  virtual void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                              int64_t value) const = 0;
+
+  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                      int32_t value) const {
+    SetNumberValue(message, static_cast<double>(value));
+  }
+
+  virtual void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                              uint64_t value) const = 0;
+
+  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                      uint32_t value) const {
+    SetNumberValue(message, static_cast<double>(value));
+  }
+
+  virtual void SetStringValue(google::protobuf::MessageLite* absl_nonnull message,
+                              absl::string_view value) const = 0;
+
+  virtual void SetStringValue(google::protobuf::MessageLite* absl_nonnull message,
+                              const absl::Cord& value) const = 0;
+
+  void SetStringValueFromBytes(google::protobuf::MessageLite* absl_nonnull message,
+                               absl::string_view value) const {
+    if (value.empty()) {
+      SetStringValue(message, value);
+      return;
+    }
+    SetStringValue(message, absl::Base64Escape(value));
+  }
+
+  void SetStringValueFromBytes(google::protobuf::MessageLite* absl_nonnull message,
+                               const absl::Cord& value) const {
+    if (value.empty()) {
+      SetStringValue(message, value);
+      return;
+    }
+    if (auto flat = value.TryFlat(); flat) {
+      SetStringValue(message, absl::Base64Escape(*flat));
+      return;
+    }
+    SetStringValue(message,
+                   absl::Base64Escape(static_cast<std::string>(value)));
+  }
+
+  virtual google::protobuf::MessageLite* absl_nonnull MutableListValue(
+      google::protobuf::MessageLite* absl_nonnull message) const = 0;
+
+  virtual google::protobuf::MessageLite* absl_nonnull MutableStructValue(
+      google::protobuf::MessageLite* absl_nonnull message) const = 0;
+
+  virtual google::protobuf::MessageLite* absl_nonnull AddValues(
+      google::protobuf::MessageLite* absl_nonnull message) const = 0;
+
+  virtual google::protobuf::MessageLite* absl_nonnull InsertField(
+      google::protobuf::MessageLite* absl_nonnull message,
+      absl::string_view name) const = 0;
+
+  const google::protobuf::DescriptorPool* absl_nonnull const descriptor_pool_;
+  google::protobuf::MessageFactory* absl_nonnull const message_factory_;
+  std::string scratch_;
+  Reflection reflection_;
+};
+
+class GeneratedMessageToJsonState final : public MessageToJsonState {
+ public:
+  using MessageToJsonState::MessageToJsonState;
+
+  absl::Status Initialize(google::protobuf::MessageLite* absl_nonnull message) override {
+    // Nothing to do.
+    return absl::OkStatus();
+  }
+
+ private:
+  void SetNullValue(google::protobuf::MessageLite* absl_nonnull message) const override {
+    ValueReflection::SetNullValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message));
+  }
+
+  void SetBoolValue(google::protobuf::MessageLite* absl_nonnull message,
+                    bool value) const override {
+    ValueReflection::SetBoolValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message), value);
+  }
+
+  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                      double value) const override {
+    ValueReflection::SetNumberValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message), value);
+  }
+
+  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                      int64_t value) const override {
+    ValueReflection::SetNumberValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message), value);
+  }
+
+  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                      uint64_t value) const override {
+    ValueReflection::SetNumberValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message), value);
+  }
+
+  void SetStringValue(google::protobuf::MessageLite* absl_nonnull message,
+                      absl::string_view value) const override {
+    ValueReflection::SetStringValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message), value);
+  }
+
+  void SetStringValue(google::protobuf::MessageLite* absl_nonnull message,
+                      const absl::Cord& value) const override {
+    ValueReflection::SetStringValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message), value);
+  }
+
+  google::protobuf::MessageLite* absl_nonnull MutableListValue(
+      google::protobuf::MessageLite* absl_nonnull message) const override {
+    return ValueReflection::MutableListValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message));
+  }
+
+  google::protobuf::MessageLite* absl_nonnull MutableStructValue(
+      google::protobuf::MessageLite* absl_nonnull message) const override {
+    return ValueReflection::MutableStructValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message));
+  }
+
+  google::protobuf::MessageLite* absl_nonnull AddValues(
+      google::protobuf::MessageLite* absl_nonnull message) const override {
+    return ListValueReflection::AddValues(
+        google::protobuf::DownCastMessage<google::protobuf::ListValue>(message));
+  }
+
+  google::protobuf::MessageLite* absl_nonnull InsertField(
+      google::protobuf::MessageLite* absl_nonnull message,
+      absl::string_view name) const override {
+    return StructReflection::InsertField(
+        google::protobuf::DownCastMessage<google::protobuf::Struct>(message), name);
+  }
+};
+
+class DynamicMessageToJsonState final : public MessageToJsonState {
+ public:
+  using MessageToJsonState::MessageToJsonState;
+
+  absl::Status Initialize(google::protobuf::MessageLite* absl_nonnull message) override {
+    CEL_RETURN_IF_ERROR(reflection_.Initialize(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message)->GetDescriptor()));
+    return absl::OkStatus();
+  }
+
+ private:
+  void SetNullValue(google::protobuf::MessageLite* absl_nonnull message) const override {
+    reflection_.Value().SetNullValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  void SetBoolValue(google::protobuf::MessageLite* absl_nonnull message,
+                    bool value) const override {
+    reflection_.Value().SetBoolValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), value);
+  }
+
+  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                      double value) const override {
+    reflection_.Value().SetNumberValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), value);
+  }
+
+  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                      int64_t value) const override {
+    reflection_.Value().SetNumberValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), value);
+  }
+
+  void SetNumberValue(google::protobuf::MessageLite* absl_nonnull message,
+                      uint64_t value) const override {
+    reflection_.Value().SetNumberValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), value);
+  }
+
+  void SetStringValue(google::protobuf::MessageLite* absl_nonnull message,
+                      absl::string_view value) const override {
+    reflection_.Value().SetStringValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), value);
+  }
+
+  void SetStringValue(google::protobuf::MessageLite* absl_nonnull message,
+                      const absl::Cord& value) const override {
+    reflection_.Value().SetStringValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), value);
+  }
+
+  google::protobuf::MessageLite* absl_nonnull MutableListValue(
+      google::protobuf::MessageLite* absl_nonnull message) const override {
+    return reflection_.Value().MutableListValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  google::protobuf::MessageLite* absl_nonnull MutableStructValue(
+      google::protobuf::MessageLite* absl_nonnull message) const override {
+    return reflection_.Value().MutableStructValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  google::protobuf::MessageLite* absl_nonnull AddValues(
+      google::protobuf::MessageLite* absl_nonnull message) const override {
+    return reflection_.ListValue().AddValues(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  google::protobuf::MessageLite* absl_nonnull InsertField(
+      google::protobuf::MessageLite* absl_nonnull message,
+      absl::string_view name) const override {
+    return reflection_.Struct().InsertField(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), name);
+  }
+
+  JsonReflection reflection_;
+};
+
+}  // namespace
+
+absl::Status MessageToJson(
+    const google::protobuf::Message& message,
+    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+    google::protobuf::MessageFactory* absl_nonnull message_factory,
+    google::protobuf::Value* absl_nonnull result) {
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(result != nullptr);
+  auto state = std::make_unique<GeneratedMessageToJsonState>(descriptor_pool,
+                                                             message_factory);
+  CEL_RETURN_IF_ERROR(state->Initialize(result));
+  return state->ToJson(message, result);
+}
+
+absl::Status MessageToJson(
+    const google::protobuf::Message& message,
+    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+    google::protobuf::MessageFactory* absl_nonnull message_factory,
+    google::protobuf::Struct* absl_nonnull result) {
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(result != nullptr);
+  auto state = std::make_unique<GeneratedMessageToJsonState>(descriptor_pool,
+                                                             message_factory);
+  CEL_RETURN_IF_ERROR(state->Initialize(result));
+  return state->ToJsonObject(message, result);
+}
+
+absl::Status MessageToJson(
+    const google::protobuf::Message& message,
+    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+    google::protobuf::MessageFactory* absl_nonnull message_factory,
+    google::protobuf::Message* absl_nonnull result) {
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(result != nullptr);
+  auto state = std::make_unique<DynamicMessageToJsonState>(descriptor_pool,
+                                                           message_factory);
+  CEL_RETURN_IF_ERROR(state->Initialize(result));
+  switch (result->GetDescriptor()->well_known_type()) {
+    case google::protobuf::Descriptor::WELLKNOWNTYPE_VALUE:
+      return state->ToJson(message, result);
+    case google::protobuf::Descriptor::WELLKNOWNTYPE_STRUCT:
+      return state->ToJsonObject(message, result);
+    default:
+      return absl::InvalidArgumentError("cannot convert message to JSON array");
+  }
+}
+
+absl::Status MessageFieldToJson(
+    const google::protobuf::Message& message,
+    const google::protobuf::FieldDescriptor* absl_nonnull field,
+    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+    google::protobuf::MessageFactory* absl_nonnull message_factory,
+    google::protobuf::Value* absl_nonnull result) {
+  ABSL_DCHECK_EQ(field->containing_type(), message.GetDescriptor());
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(result != nullptr);
+  auto state = std::make_unique<GeneratedMessageToJsonState>(descriptor_pool,
+                                                             message_factory);
+  CEL_RETURN_IF_ERROR(state->Initialize(result));
+  return state->FieldToJson(message, field, result);
+}
+
+absl::Status MessageFieldToJson(
+    const google::protobuf::Message& message,
+    const google::protobuf::FieldDescriptor* absl_nonnull field,
+    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+    google::protobuf::MessageFactory* absl_nonnull message_factory,
+    google::protobuf::ListValue* absl_nonnull result) {
+  ABSL_DCHECK_EQ(field->containing_type(), message.GetDescriptor());
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(result != nullptr);
+  auto state = std::make_unique<GeneratedMessageToJsonState>(descriptor_pool,
+                                                             message_factory);
+  CEL_RETURN_IF_ERROR(state->Initialize(result));
+  return state->FieldToJsonArray(message, field, result);
+}
+
+absl::Status MessageFieldToJson(
+    const google::protobuf::Message& message,
+    const google::protobuf::FieldDescriptor* absl_nonnull field,
+    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+    google::protobuf::MessageFactory* absl_nonnull message_factory,
+    google::protobuf::Struct* absl_nonnull result) {
+  ABSL_DCHECK_EQ(field->containing_type(), message.GetDescriptor());
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(result != nullptr);
+  auto state = std::make_unique<GeneratedMessageToJsonState>(descriptor_pool,
+                                                             message_factory);
+  CEL_RETURN_IF_ERROR(state->Initialize(result));
+  return state->FieldToJsonObject(message, field, result);
+}
+
+absl::Status MessageFieldToJson(
+    const google::protobuf::Message& message,
+    const google::protobuf::FieldDescriptor* absl_nonnull field,
+    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+    google::protobuf::MessageFactory* absl_nonnull message_factory,
+    google::protobuf::Message* absl_nonnull result) {
+  ABSL_DCHECK_EQ(field->containing_type(), message.GetDescriptor());
+  ABSL_DCHECK(descriptor_pool != nullptr);
+  ABSL_DCHECK(message_factory != nullptr);
+  ABSL_DCHECK(result != nullptr);
+  auto state = std::make_unique<DynamicMessageToJsonState>(descriptor_pool,
+                                                           message_factory);
+  CEL_RETURN_IF_ERROR(state->Initialize(result));
+  switch (result->GetDescriptor()->well_known_type()) {
+    case google::protobuf::Descriptor::WELLKNOWNTYPE_VALUE:
+      return state->FieldToJson(message, field, result);
+    case google::protobuf::Descriptor::WELLKNOWNTYPE_LISTVALUE:
+      return state->FieldToJsonArray(message, field, result);
+    case google::protobuf::Descriptor::WELLKNOWNTYPE_STRUCT:
+      return state->FieldToJsonObject(message, field, result);
+    default:
+      return absl::InternalError("unreachable");
+  }
+}
+
+absl::Status CheckJson(const google::protobuf::MessageLite& message) {
+  if (const auto* generated_message =
+          google::protobuf::DynamicCastMessage<google::protobuf::Value>(&message);
+      generated_message) {
+    return absl::OkStatus();
+  }
+  if (const auto* dynamic_message =
+          google::protobuf::DynamicCastMessage<google::protobuf::Message>(&message);
+      dynamic_message) {
+    CEL_ASSIGN_OR_RETURN(auto reflection,
+                         GetValueReflection(dynamic_message->GetDescriptor()));
+    CEL_RETURN_IF_ERROR(
+        GetListValueReflection(reflection.GetListValueDescriptor()).status());
+    CEL_RETURN_IF_ERROR(
+        GetStructReflection(reflection.GetStructDescriptor()).status());
+    return absl::OkStatus();
+  }
+  return absl::InvalidArgumentError(
+      absl::StrCat("message must be an instance of `google.protobuf.Value`: ",
+                   message.GetTypeName()));
+}
+
+absl::Status CheckJsonList(const google::protobuf::MessageLite& message) {
+  if (const auto* generated_message =
+          google::protobuf::DynamicCastMessage<google::protobuf::ListValue>(&message);
+      generated_message) {
+    return absl::OkStatus();
+  }
+  if (const auto* dynamic_message =
+          google::protobuf::DynamicCastMessage<google::protobuf::Message>(&message);
+      dynamic_message) {
+    CEL_ASSIGN_OR_RETURN(
+        auto reflection,
+        GetListValueReflection(dynamic_message->GetDescriptor()));
+    CEL_ASSIGN_OR_RETURN(auto value_reflection,
+                         GetValueReflection(reflection.GetValueDescriptor()));
+    CEL_RETURN_IF_ERROR(
+        GetStructReflection(value_reflection.GetStructDescriptor()).status());
+    return absl::OkStatus();
+  }
+  return absl::InvalidArgumentError(absl::StrCat(
+      "message must be an instance of `google.protobuf.ListValue`: ",
+      message.GetTypeName()));
+}
+
+absl::Status CheckJsonMap(const google::protobuf::MessageLite& message) {
+  if (const auto* generated_message =
+          google::protobuf::DynamicCastMessage<google::protobuf::Struct>(&message);
+      generated_message) {
+    return absl::OkStatus();
+  }
+  if (const auto* dynamic_message =
+          google::protobuf::DynamicCastMessage<google::protobuf::Message>(&message);
+      dynamic_message) {
+    CEL_ASSIGN_OR_RETURN(auto reflection,
+                         GetStructReflection(dynamic_message->GetDescriptor()));
+    CEL_ASSIGN_OR_RETURN(auto value_reflection,
+                         GetValueReflection(reflection.GetValueDescriptor()));
+    CEL_RETURN_IF_ERROR(
+        GetListValueReflection(value_reflection.GetListValueDescriptor())
+            .status());
+    return absl::OkStatus();
+  }
+  return absl::InvalidArgumentError(
+      absl::StrCat("message must be an instance of `google.protobuf.Struct`: ",
+                   message.GetTypeName()));
+}
+
+namespace {
+
+class JsonMapIterator final {
+ public:
+  using Generated =
+      typename google::protobuf::Map<std::string,
+                           google::protobuf::Value>::const_iterator;
+  using Dynamic = google::protobuf::ConstMapIterator;
+  using Value = std::pair<well_known_types::StringValue,
+                          const google::protobuf::MessageLite* absl_nonnull>;
+
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  JsonMapIterator(Generated generated) : variant_(std::move(generated)) {}
+
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  JsonMapIterator(Dynamic dynamic) : variant_(std::move(dynamic)) {}
+
+  JsonMapIterator(const JsonMapIterator&) = default;
+  JsonMapIterator(JsonMapIterator&&) = default;
+  JsonMapIterator& operator=(const JsonMapIterator&) = default;
+  JsonMapIterator& operator=(JsonMapIterator&&) = default;
+
+  Value Next(std::string& scratch ABSL_ATTRIBUTE_LIFETIME_BOUND) {
+    Value result;
+    absl::visit(absl::Overload(
+                    [&](Generated& generated) -> void {
+                      result = std::pair{absl::string_view(generated->first),
+                                         &generated->second};
+                      ++generated;
+                    },
+                    [&](Dynamic& dynamic) -> void {
+                      const auto& key = dynamic.GetKey().GetStringValue();
+                      scratch.assign(key.data(), key.size());
+                      result =
+                          std::pair{absl::string_view(scratch),
+                                    &dynamic.GetValueRef().GetMessageValue()};
+                      ++dynamic;
+                    }),
+                variant_);
+    return result;
+  }
+
+ private:
+  std::variant<Generated, Dynamic> variant_;
+};
+
+class JsonAccessor {
+ public:
+  virtual ~JsonAccessor() = default;
+
+  virtual google::protobuf::Value::KindCase GetKindCase(
+      const google::protobuf::MessageLite& message) const = 0;
+
+  virtual bool GetBoolValue(const google::protobuf::MessageLite& message) const = 0;
+
+  virtual double GetNumberValue(const google::protobuf::MessageLite& message) const = 0;
+
+  virtual well_known_types::StringValue GetStringValue(
+      const google::protobuf::MessageLite& message,
+      std::string& scratch ABSL_ATTRIBUTE_LIFETIME_BOUND) const = 0;
+
+  virtual const google::protobuf::MessageLite& GetListValue(
+      const google::protobuf::MessageLite& message) const = 0;
+
+  virtual int ValuesSize(const google::protobuf::MessageLite& message) const = 0;
+
+  virtual const google::protobuf::MessageLite& Values(const google::protobuf::MessageLite& message,
+                                            int index) const = 0;
+
+  virtual const google::protobuf::MessageLite& GetStructValue(
+      const google::protobuf::MessageLite& message) const = 0;
+
+  virtual int FieldsSize(const google::protobuf::MessageLite& message) const = 0;
+
+  virtual const google::protobuf::MessageLite* absl_nullable FindField(
+      const google::protobuf::MessageLite& message, absl::string_view name) const = 0;
+
+  virtual JsonMapIterator IterateFields(
+      const google::protobuf::MessageLite& message) const = 0;
+};
+
+class GeneratedJsonAccessor final : public JsonAccessor {
+ public:
+  static const GeneratedJsonAccessor* absl_nonnull Singleton() {
+    static const absl::NoDestructor<GeneratedJsonAccessor> singleton;
+    return &*singleton;
+  }
+
+  google::protobuf::Value::KindCase GetKindCase(
+      const google::protobuf::MessageLite& message) const override {
+    return ValueReflection::GetKindCase(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message));
+  }
+
+  bool GetBoolValue(const google::protobuf::MessageLite& message) const override {
+    return ValueReflection::GetBoolValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message));
+  }
+
+  double GetNumberValue(const google::protobuf::MessageLite& message) const override {
+    return ValueReflection::GetNumberValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message));
+  }
+
+  well_known_types::StringValue GetStringValue(
+      const google::protobuf::MessageLite& message, std::string&) const override {
+    return ValueReflection::GetStringValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message));
+  }
+
+  const google::protobuf::MessageLite& GetListValue(
+      const google::protobuf::MessageLite& message) const override {
+    return ValueReflection::GetListValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message));
+  }
+
+  int ValuesSize(const google::protobuf::MessageLite& message) const override {
+    return ListValueReflection::ValuesSize(
+        google::protobuf::DownCastMessage<google::protobuf::ListValue>(message));
+  }
+
+  const google::protobuf::MessageLite& Values(const google::protobuf::MessageLite& message,
+                                    int index) const override {
+    return ListValueReflection::Values(
+        google::protobuf::DownCastMessage<google::protobuf::ListValue>(message), index);
+  }
+
+  const google::protobuf::MessageLite& GetStructValue(
+      const google::protobuf::MessageLite& message) const override {
+    return ValueReflection::GetStructValue(
+        google::protobuf::DownCastMessage<google::protobuf::Value>(message));
+  }
+
+  int FieldsSize(const google::protobuf::MessageLite& message) const override {
+    return StructReflection::FieldsSize(
+        google::protobuf::DownCastMessage<google::protobuf::Struct>(message));
+  }
+
+  const google::protobuf::MessageLite* absl_nullable FindField(
+      const google::protobuf::MessageLite& message,
+      absl::string_view name) const override {
+    return StructReflection::FindField(
+        google::protobuf::DownCastMessage<google::protobuf::Struct>(message), name);
+  }
+
+  JsonMapIterator IterateFields(
+      const google::protobuf::MessageLite& message) const override {
+    return StructReflection::BeginFields(
+        google::protobuf::DownCastMessage<google::protobuf::Struct>(message));
+  }
+};
+
+class DynamicJsonAccessor final : public JsonAccessor {
+ public:
+  void InitializeValue(const google::protobuf::Message& message) {
+    ABSL_CHECK_OK(reflection_.Initialize(message.GetDescriptor()));  // Crash OK
+  }
+
+  void InitializeListValue(const google::protobuf::Message& message) {
+    ABSL_CHECK_OK(reflection_.Initialize(message.GetDescriptor()));  // Crash OK
+  }
+
+  void InitializeStruct(const google::protobuf::Message& message) {
+    ABSL_CHECK_OK(reflection_.Initialize(message.GetDescriptor()));  // Crash OK
+  }
+
+  google::protobuf::Value::KindCase GetKindCase(
+      const google::protobuf::MessageLite& message) const override {
+    return reflection_.Value().GetKindCase(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  bool GetBoolValue(const google::protobuf::MessageLite& message) const override {
+    return reflection_.Value().GetBoolValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  double GetNumberValue(const google::protobuf::MessageLite& message) const override {
+    return reflection_.Value().GetNumberValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  well_known_types::StringValue GetStringValue(
+      const google::protobuf::MessageLite& message, std::string& scratch) const override {
+    return reflection_.Value().GetStringValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), scratch);
+  }
+
+  const google::protobuf::MessageLite& GetListValue(
+      const google::protobuf::MessageLite& message) const override {
+    return reflection_.Value().GetListValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  int ValuesSize(const google::protobuf::MessageLite& message) const override {
+    return reflection_.ListValue().ValuesSize(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  const google::protobuf::MessageLite& Values(const google::protobuf::MessageLite& message,
+                                    int index) const override {
+    return reflection_.ListValue().Values(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), index);
+  }
+
+  const google::protobuf::MessageLite& GetStructValue(
+      const google::protobuf::MessageLite& message) const override {
+    return reflection_.Value().GetStructValue(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  int FieldsSize(const google::protobuf::MessageLite& message) const override {
+    return reflection_.Struct().FieldsSize(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+  const google::protobuf::MessageLite* absl_nullable FindField(
+      const google::protobuf::MessageLite& message,
+      absl::string_view name) const override {
+    return reflection_.Struct().FindField(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message), name);
+  }
+
+  JsonMapIterator IterateFields(
+      const google::protobuf::MessageLite& message) const override {
+    return reflection_.Struct().BeginFields(
+        google::protobuf::DownCastMessage<google::protobuf::Message>(message));
+  }
+
+ private:
+  JsonReflection reflection_;
+};
+
+std::string JsonStringDebugString(const well_known_types::StringValue& value) {
+  return absl::visit(absl::Overload(
+                         [&](absl::string_view string) -> std::string {
+                           return FormatStringLiteral(string);
+                         },
+                         [&](const absl::Cord& cord) -> std::string {
+                           return FormatStringLiteral(cord);
+                         }),
+                     well_known_types::AsVariant(value));
+}
+
+std::string JsonNumberDebugString(double value) {
+  if (std::isfinite(value)) {
+    if (std::floor(value) != value) {
+      // The double is not representable as a whole number, so use
+      // absl::StrCat which will add decimal places.
+      return absl::StrCat(value);
+    }
+    // absl::StrCat historically would represent 0.0 as 0, and we want the
+    // decimal places so ZetaSQL correctly assumes the type as double
+    // instead of int64.
+    std::string stringified = absl::StrCat(value);
+    if (!absl::StrContains(stringified, '.')) {
+      absl::StrAppend(&stringified, ".0");
+    } else {
+      // absl::StrCat has a decimal now? Use it directly.
+    }
+    return stringified;
+  }
+  if (std::isnan(value)) {
+    return "nan";
+  }
+  if (std::signbit(value)) {
+    return "-infinity";
+  }
+  return "+infinity";
+}
+
+class JsonDebugStringState final {
+ public:
+  JsonDebugStringState(const JsonAccessor* absl_nonnull accessor,
+                       std::string* absl_nonnull output)
+      : accessor_(accessor), output_(output) {}
+
+  void ValueDebugString(const google::protobuf::MessageLite& message) {
+    const auto kind_case = accessor_->GetKindCase(message);
+    switch (kind_case) {
+      case google::protobuf::Value::KIND_NOT_SET:
+        ABSL_FALLTHROUGH_INTENDED;
+      case google::protobuf::Value::kNullValue:
+        output_->append("null");
+        break;
+      case google::protobuf::Value::kBoolValue:
+        if (accessor_->GetBoolValue(message)) {
+          output_->append("true");
+        } else {
+          output_->append("false");
+        }
+        break;
+      case google::protobuf::Value::kNumberValue:
+        output_->append(
+            JsonNumberDebugString(accessor_->GetNumberValue(message)));
+        break;
+      case google::protobuf::Value::kStringValue:
+        output_->append(JsonStringDebugString(
+            accessor_->GetStringValue(message, scratch_)));
+        break;
+      case google::protobuf::Value::kListValue:
+        ListValueDebugString(accessor_->GetListValue(message));
+        break;
+      case google::protobuf::Value::kStructValue:
+        StructDebugString(accessor_->GetStructValue(message));
+        break;
+      default:
+        // Should not get here, but if for some terrible reason
+        // `google.protobuf.Value` is expanded, just skip.
+        break;
+    }
+  }
+
+  void ListValueDebugString(const google::protobuf::MessageLite& message) {
+    const int size = accessor_->ValuesSize(message);
+    output_->push_back('[');
+    for (int i = 0; i < size; ++i) {
+      if (i > 0) {
+        output_->append(", ");
+      }
+      ValueDebugString(accessor_->Values(message, i));
+    }
+    output_->push_back(']');
+  }
+
+  void StructDebugString(const google::protobuf::MessageLite& message) {
+    const int size = accessor_->FieldsSize(message);
+    std::string key_scratch;
+    well_known_types::StringValue key;
+    const google::protobuf::MessageLite* absl_nonnull value;
+    auto iterator = accessor_->IterateFields(message);
+    output_->push_back('{');
+    for (int i = 0; i < size; ++i) {
+      if (i > 0) {
+        output_->append(", ");
+      }
+      std::tie(key, value) = iterator.Next(key_scratch);
+      output_->append(JsonStringDebugString(key));
+      output_->append(": ");
+      ValueDebugString(*value);
+    }
+    output_->push_back('}');
+  }
+
+ private:
+  const JsonAccessor* absl_nonnull const accessor_;
+  std::string* absl_nonnull const output_;
+  std::string scratch_;
+};
+
+}  // namespace
+
+std::string JsonDebugString(const google::protobuf::Value& message) {
+  std::string output;
+  JsonDebugStringState(GeneratedJsonAccessor::Singleton(), &output)
+      .ValueDebugString(message);
+  return output;
+}
+
+std::string JsonDebugString(const google::protobuf::Message& message) {
+  DynamicJsonAccessor accessor;
+  accessor.InitializeValue(message);
+  std::string output;
+  JsonDebugStringState(&accessor, &output).ValueDebugString(message);
+  return output;
+}
+
+std::string JsonListDebugString(const google::protobuf::ListValue& message) {
+  std::string output;
+  JsonDebugStringState(GeneratedJsonAccessor::Singleton(), &output)
+      .ListValueDebugString(message);
+  return output;
+}
+
+std::string JsonListDebugString(const google::protobuf::Message& message) {
+  DynamicJsonAccessor accessor;
+  accessor.InitializeListValue(message);
+  std::string output;
+  JsonDebugStringState(&accessor, &output).ListValueDebugString(message);
+  return output;
+}
+
+std::string JsonMapDebugString(const google::protobuf::Struct& message) {
+  std::string output;
+  JsonDebugStringState(GeneratedJsonAccessor::Singleton(), &output)
+      .StructDebugString(message);
+  return output;
+}
+
+std::string JsonMapDebugString(const google::protobuf::Message& message) {
+  DynamicJsonAccessor accessor;
+  accessor.InitializeStruct(message);
+  std::string output;
+  JsonDebugStringState(&accessor, &output).StructDebugString(message);
+  return output;
+}
+
+namespace {
+
+class JsonEqualsState final {
+ public:
+  explicit JsonEqualsState(const JsonAccessor* absl_nonnull lhs_accessor,
+                           const JsonAccessor* absl_nonnull rhs_accessor)
+      : lhs_accessor_(lhs_accessor), rhs_accessor_(rhs_accessor) {}
+
+  bool ValueEqual(const google::protobuf::MessageLite& lhs,
+                  const google::protobuf::MessageLite& rhs) {
+    auto lhs_kind_case = lhs_accessor_->GetKindCase(lhs);
+    if (lhs_kind_case == google::protobuf::Value::KIND_NOT_SET) {
+      lhs_kind_case = google::protobuf::Value::kNullValue;
+    }
+    auto rhs_kind_case = rhs_accessor_->GetKindCase(rhs);
+    if (rhs_kind_case == google::protobuf::Value::KIND_NOT_SET) {
+      rhs_kind_case = google::protobuf::Value::kNullValue;
+    }
+    if (lhs_kind_case != rhs_kind_case) {
+      return false;
+    }
+    switch (lhs_kind_case) {
+      case google::protobuf::Value::KIND_NOT_SET:
+        ABSL_UNREACHABLE();
+      case google::protobuf::Value::kNullValue:
+        return true;
+      case google::protobuf::Value::kBoolValue:
+        return lhs_accessor_->GetBoolValue(lhs) ==
+               rhs_accessor_->GetBoolValue(rhs);
+      case google::protobuf::Value::kNumberValue:
+        return lhs_accessor_->GetNumberValue(lhs) ==
+               rhs_accessor_->GetNumberValue(rhs);
+      case google::protobuf::Value::kStringValue:
+        return lhs_accessor_->GetStringValue(lhs, lhs_scratch_) ==
+               rhs_accessor_->GetStringValue(rhs, rhs_scratch_);
+      case google::protobuf::Value::kListValue:
+        return ListValueEqual(lhs_accessor_->GetListValue(lhs),
+                              rhs_accessor_->GetListValue(rhs));
+      case google::protobuf::Value::kStructValue:
+        return StructEqual(lhs_accessor_->GetStructValue(lhs),
+                           rhs_accessor_->GetStructValue(rhs));
+      default:
+        // Should not get here, but if for some terrible reason
+        // `google.protobuf.Value` is expanded, default to false.
+        return false;
+    }
+  }
+
+  bool ListValueEqual(const google::protobuf::MessageLite& lhs,
+                      const google::protobuf::MessageLite& rhs) {
+    const int lhs_size = lhs_accessor_->ValuesSize(lhs);
+    const int rhs_size = rhs_accessor_->ValuesSize(rhs);
+    if (lhs_size != rhs_size) {
+      return false;
+    }
+    for (int i = 0; i < lhs_size; ++i) {
+      if (!ValueEqual(lhs_accessor_->Values(lhs, i),
+                      rhs_accessor_->Values(rhs, i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool StructEqual(const google::protobuf::MessageLite& lhs,
+                   const google::protobuf::MessageLite& rhs) {
+    const int lhs_size = lhs_accessor_->FieldsSize(lhs);
+    const int rhs_size = rhs_accessor_->FieldsSize(rhs);
+    if (lhs_size != rhs_size) {
+      return false;
+    }
+    if (lhs_size == 0) {
+      return true;
+    }
+    std::string lhs_key_scratch;
+    well_known_types::StringValue lhs_key;
+    const google::protobuf::MessageLite* absl_nonnull lhs_value;
+    auto lhs_iterator = lhs_accessor_->IterateFields(lhs);
+    for (int i = 0; i < lhs_size; ++i) {
+      std::tie(lhs_key, lhs_value) = lhs_iterator.Next(lhs_key_scratch);
+      if (const auto* rhs_value = rhs_accessor_->FindField(
+              rhs, absl::visit(
+                       absl::Overload(
+                           [](absl::string_view string) -> absl::string_view {
+                             return string;
+                           },
+                           [&lhs_key_scratch](
+                               const absl::Cord& cord) -> absl::string_view {
+                             if (auto flat = cord.TryFlat(); flat) {
+                               return *flat;
+                             }
+                             absl::CopyCordToString(cord, &lhs_key_scratch);
+                             return absl::string_view(lhs_key_scratch);
+                           }),
+                       AsVariant(lhs_key)));
+          rhs_value == nullptr || !ValueEqual(*lhs_value, *rhs_value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+ private:
+  const JsonAccessor* absl_nonnull const lhs_accessor_;
+  const JsonAccessor* absl_nonnull const rhs_accessor_;
+  std::string lhs_scratch_;
+  std::string rhs_scratch_;
+};
+
+}  // namespace
+
+bool JsonEquals(const google::protobuf::Value& lhs,
+                const google::protobuf::Value& rhs) {
+  return JsonEqualsState(GeneratedJsonAccessor::Singleton(),
+                         GeneratedJsonAccessor::Singleton())
+      .ValueEqual(lhs, rhs);
+}
+
+bool JsonEquals(const google::protobuf::Value& lhs,
+                const google::protobuf::Message& rhs) {
+  DynamicJsonAccessor rhs_accessor;
+  rhs_accessor.InitializeValue(rhs);
+  return JsonEqualsState(GeneratedJsonAccessor::Singleton(), &rhs_accessor)
+      .ValueEqual(lhs, rhs);
+}
+
+bool JsonEquals(const google::protobuf::Message& lhs,
+                const google::protobuf::Value& rhs) {
+  DynamicJsonAccessor lhs_accessor;
+  lhs_accessor.InitializeValue(lhs);
+  return JsonEqualsState(&lhs_accessor, GeneratedJsonAccessor::Singleton())
+      .ValueEqual(lhs, rhs);
+}
+
+bool JsonEquals(const google::protobuf::Message& lhs, const google::protobuf::Message& rhs) {
+  DynamicJsonAccessor lhs_accessor;
+  lhs_accessor.InitializeValue(lhs);
+  DynamicJsonAccessor rhs_accessor;
+  rhs_accessor.InitializeValue(rhs);
+  return JsonEqualsState(&lhs_accessor, &rhs_accessor).ValueEqual(lhs, rhs);
+}
+
+bool JsonEquals(const google::protobuf::MessageLite& lhs,
+                const google::protobuf::MessageLite& rhs) {
+  const auto* lhs_generated =
+      google::protobuf::DynamicCastMessage<google::protobuf::Value>(&lhs);
+  const auto* rhs_generated =
+      google::protobuf::DynamicCastMessage<google::protobuf::Value>(&rhs);
+  if (lhs_generated && rhs_generated) {
+    return JsonEquals(*lhs_generated, *rhs_generated);
+  }
+  if (lhs_generated) {
+    return JsonEquals(*lhs_generated,
+                      google::protobuf::DownCastMessage<google::protobuf::Message>(rhs));
+  }
+  if (rhs_generated) {
+    return JsonEquals(google::protobuf::DownCastMessage<google::protobuf::Message>(lhs),
+                      *rhs_generated);
+  }
+  return JsonEquals(google::protobuf::DownCastMessage<google::protobuf::Message>(lhs),
+                    google::protobuf::DownCastMessage<google::protobuf::Message>(rhs));
+}
+
+bool JsonListEquals(const google::protobuf::ListValue& lhs,
+                    const google::protobuf::ListValue& rhs) {
+  return JsonEqualsState(GeneratedJsonAccessor::Singleton(),
+                         GeneratedJsonAccessor::Singleton())
+      .ListValueEqual(lhs, rhs);
+}
+
+bool JsonListEquals(const google::protobuf::ListValue& lhs,
+                    const google::protobuf::Message& rhs) {
+  DynamicJsonAccessor rhs_accessor;
+  rhs_accessor.InitializeListValue(rhs);
+  return JsonEqualsState(GeneratedJsonAccessor::Singleton(), &rhs_accessor)
+      .ListValueEqual(lhs, rhs);
+}
+
+bool JsonListEquals(const google::protobuf::Message& lhs,
+                    const google::protobuf::ListValue& rhs) {
+  DynamicJsonAccessor lhs_accessor;
+  lhs_accessor.InitializeListValue(lhs);
+  return JsonEqualsState(&lhs_accessor, GeneratedJsonAccessor::Singleton())
+      .ListValueEqual(lhs, rhs);
+}
+
+bool JsonListEquals(const google::protobuf::Message& lhs, const google::protobuf::Message& rhs) {
+  DynamicJsonAccessor lhs_accessor;
+  lhs_accessor.InitializeListValue(lhs);
+  DynamicJsonAccessor rhs_accessor;
+  rhs_accessor.InitializeListValue(rhs);
+  return JsonEqualsState(&lhs_accessor, &rhs_accessor).ListValueEqual(lhs, rhs);
+}
+
+bool JsonListEquals(const google::protobuf::MessageLite& lhs,
+                    const google::protobuf::MessageLite& rhs) {
+  const auto* lhs_generated =
+      google::protobuf::DynamicCastMessage<google::protobuf::ListValue>(&lhs);
+  const auto* rhs_generated =
+      google::protobuf::DynamicCastMessage<google::protobuf::ListValue>(&rhs);
+  if (lhs_generated && rhs_generated) {
+    return JsonListEquals(*lhs_generated, *rhs_generated);
+  }
+  if (lhs_generated) {
+    return JsonListEquals(*lhs_generated,
+                          google::protobuf::DownCastMessage<google::protobuf::Message>(rhs));
+  }
+  if (rhs_generated) {
+    return JsonListEquals(google::protobuf::DownCastMessage<google::protobuf::Message>(lhs),
+                          *rhs_generated);
+  }
+  return JsonListEquals(google::protobuf::DownCastMessage<google::protobuf::Message>(lhs),
+                        google::protobuf::DownCastMessage<google::protobuf::Message>(rhs));
+}
+
+bool JsonMapEquals(const google::protobuf::Struct& lhs,
+                   const google::protobuf::Struct& rhs) {
+  return JsonEqualsState(GeneratedJsonAccessor::Singleton(),
+                         GeneratedJsonAccessor::Singleton())
+      .StructEqual(lhs, rhs);
+}
+
+bool JsonMapEquals(const google::protobuf::Struct& lhs,
+                   const google::protobuf::Message& rhs) {
+  DynamicJsonAccessor rhs_accessor;
+  rhs_accessor.InitializeStruct(rhs);
+  return JsonEqualsState(GeneratedJsonAccessor::Singleton(), &rhs_accessor)
+      .StructEqual(lhs, rhs);
+}
+
+bool JsonMapEquals(const google::protobuf::Message& lhs,
+                   const google::protobuf::Struct& rhs) {
+  DynamicJsonAccessor lhs_accessor;
+  lhs_accessor.InitializeStruct(lhs);
+  return JsonEqualsState(&lhs_accessor, GeneratedJsonAccessor::Singleton())
+      .StructEqual(lhs, rhs);
+}
+
+bool JsonMapEquals(const google::protobuf::Message& lhs, const google::protobuf::Message& rhs) {
+  DynamicJsonAccessor lhs_accessor;
+  lhs_accessor.InitializeStruct(lhs);
+  DynamicJsonAccessor rhs_accessor;
+  rhs_accessor.InitializeStruct(rhs);
+  return JsonEqualsState(&lhs_accessor, &rhs_accessor).StructEqual(lhs, rhs);
+}
+
+bool JsonMapEquals(const google::protobuf::MessageLite& lhs,
+                   const google::protobuf::MessageLite& rhs) {
+  const auto* lhs_generated =
+      google::protobuf::DynamicCastMessage<google::protobuf::Struct>(&lhs);
+  const auto* rhs_generated =
+      google::protobuf::DynamicCastMessage<google::protobuf::Struct>(&rhs);
+  if (lhs_generated && rhs_generated) {
+    return JsonMapEquals(*lhs_generated, *rhs_generated);
+  }
+  if (lhs_generated) {
+    return JsonMapEquals(*lhs_generated,
+                         google::protobuf::DownCastMessage<google::protobuf::Message>(rhs));
+  }
+  if (rhs_generated) {
+    return JsonMapEquals(google::protobuf::DownCastMessage<google::protobuf::Message>(lhs),
+                         *rhs_generated);
+  }
+  return JsonMapEquals(google::protobuf::DownCastMessage<google::protobuf::Message>(lhs),
+                       google::protobuf::DownCastMessage<google::protobuf::Message>(rhs));
+}
+
+}  // namespace cel::internal