/proc/self/cwd/common/value.h

Source
// Copyright 2023 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.

#ifndef THIRD_PARTY_CEL_CPP_COMMON_VALUE_H_
#define THIRD_PARTY_CEL_CPP_COMMON_VALUE_H_

#include <cstddef>
#include <cstdint>
#include <cstring>
#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <type_traits>
#include <utility>

#include "absl/base/attributes.h"
#include "absl/base/nullability.h"
#include "absl/log/absl_check.h"
#include "absl/meta/type_traits.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "absl/types/span.h"
#include "absl/utility/utility.h"
#include "base/attribute.h"
#include "common/arena.h"
#include "common/native_type.h"
#include "common/optional_ref.h"
#include "common/type.h"
#include "common/typeinfo.h"
#include "common/value_kind.h"
#include "common/values/bool_value.h"  // IWYU pragma: export
#include "common/values/bytes_value.h"  // IWYU pragma: export
#include "common/values/bytes_value_input_stream.h"  // IWYU pragma: export
#include "common/values/bytes_value_output_stream.h"  // IWYU pragma: export
#include "common/values/custom_list_value.h"  // IWYU pragma: export
#include "common/values/custom_map_value.h"  // IWYU pragma: export
#include "common/values/custom_struct_value.h"  // IWYU pragma: export
#include "common/values/double_value.h"  // IWYU pragma: export
#include "common/values/duration_value.h"  // IWYU pragma: export
#include "common/values/enum_value.h"  // IWYU pragma: export
#include "common/values/error_value.h"  // IWYU pragma: export
#include "common/values/int_value.h"  // IWYU pragma: export
#include "common/values/list_value.h"  // IWYU pragma: export
#include "common/values/map_value.h"  // IWYU pragma: export
#include "common/values/message_value.h"  // IWYU pragma: export
#include "common/values/null_value.h"  // IWYU pragma: export
#include "common/values/opaque_value.h"  // IWYU pragma: export
#include "common/values/optional_value.h"  // IWYU pragma: export
#include "common/values/parsed_json_list_value.h"  // IWYU pragma: export
#include "common/values/parsed_json_map_value.h"  // IWYU pragma: export
#include "common/values/parsed_map_field_value.h"  // IWYU pragma: export
#include "common/values/parsed_message_value.h"  // IWYU pragma: export
#include "common/values/parsed_repeated_field_value.h"  // IWYU pragma: export
#include "common/values/string_value.h"  // IWYU pragma: export
#include "common/values/struct_value.h"  // IWYU pragma: export
#include "common/values/timestamp_value.h"  // IWYU pragma: export
#include "common/values/type_value.h"  // IWYU pragma: export
#include "common/values/uint_value.h"  // IWYU pragma: export
#include "common/values/unknown_value.h"  // IWYU pragma: export
#include "common/values/value_variant.h"
#include "common/values/values.h"
#include "internal/status_macros.h"
#include "runtime/runtime_options.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/io/zero_copy_stream.h"
#include "google/protobuf/map_field.h"
#include "google/protobuf/message.h"

#pragma push_macro("GetMessage")
#ifdef GetMessage
// GetMessage in windows API headers might be defined as a macro. Depending on
// ordering, might cause issues with Value::GetMessage or
// google::protobuf::Reflection::GetMessage.
#undef GetMessage
#endif

namespace cel {

// `Value` is a composition type which encompasses all values supported by the
// Common Expression Language. When default constructed or moved, `Value` is in
// a known but invalid state. Any attempt to use it from then on, without
// assigning another type, is undefined behavior. In debug builds, we do our
// best to fail.
class Value final : private common_internal::ValueMixin<Value> {
 public:
  // Returns an appropriate `Value` for the dynamic protobuf enum. For open
  // enums, returns `cel::IntValue`. For closed enums, returns `cel::ErrorValue`
  // if the value is not present in the enum otherwise returns `cel::IntValue`.
  static Value Enum(const google::protobuf::EnumValueDescriptor* absl_nonnull value);
  ABSL_DEPRECATED("Use overload which takes an arena pointer")
  static Value Enum(const google::protobuf::EnumDescriptor* absl_nonnull type,
                    int32_t number);
  static Value Enum(const google::protobuf::EnumDescriptor* absl_nonnull type,
                    int32_t number, google::protobuf::Arena* absl_nonnull arena);

  // SFINAE overload for generated protobuf enums which are not well-known.
  // Always returns `cel::IntValue`.
  template <typename T>
  static common_internal::EnableIfGeneratedEnum<T, IntValue> Enum(T value) {
    return IntValue(value);
  }

  // SFINAE overload for google::protobuf::NullValue. Always returns
  // `cel::NullValue`.
  template <typename T>
  static common_internal::EnableIfWellKnownEnum<T, google::protobuf::NullValue,
                                                NullValue>
  Enum(T) {
    return NullValue();
  }

  // Returns an appropriate `Value` for the dynamic protobuf message. If
  // `message` is the well known type `google.protobuf.Any`, `descriptor_pool`
  // and `message_factory` will be used to unpack the value. Both must outlive
  // the resulting value and any of its shallow copies. Otherwise the message is
  // copied using `arena`.
  static Value FromMessage(
      const google::protobuf::Message& message,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);
  static Value FromMessage(
      google::protobuf::Message&& message,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);

  // Returns an appropriate `Value` for the dynamic protobuf message. If
  // `message` is the well known type `google.protobuf.Any`, `descriptor_pool`
  // and `message_factory` will be used to unpack the value. Both must outlive
  // the resulting value and any of its shallow copies. Otherwise the message is
  // borrowed (no copying). If the message is on an arena, that arena will be
  // attributed as the owner. Otherwise `arena` is used.
  static Value WrapMessage(
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);

  // Returns an appropriate `Value` for the dynamic protobuf message. If
  // `message` is the well known type `google.protobuf.Any`, `descriptor_pool`
  // and `message_factory` will be used to unpack the value. Both must outlive
  // the resulting value and any of its shallow copies. Otherwise the message is
  // borrowed (no copying). This function does not attempt to validate arena
  // ownership of a dynamic message that was not unpacked from a well known
  // type. Caller is responsible for ensuring the resulting value and any
  // derived values do not outlive the input message.
  static Value WrapMessageUnsafe(
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);

  // Returns an appropriate `Value` for the dynamic protobuf message field. If
  // `field` in `message` is the well known type `google.protobuf.Any`,
  // `descriptor_pool` and `message_factory` will be used to unpack the value.
  // Both must outlive the resulting value and any of its shallow copies.
  // Otherwise the field is borrowed (no copying). If the message is on an
  // arena, that arena will be attributed as the owner. Otherwise `arena` is
  // used.
  static Value WrapField(
      ProtoWrapperTypeOptions wrapper_type_options,
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::FieldDescriptor* absl_nonnull field
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);
  static Value WrapField(
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::FieldDescriptor* absl_nonnull field
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND) {
    return WrapField(ProtoWrapperTypeOptions::kUnsetNull, message, field,
                     descriptor_pool, message_factory, arena);
  }

  // Returns an appropriate `Value` for the dynamic protobuf message field. If
  // `field` in `message` is the well known type `google.protobuf.Any`,
  // `descriptor_pool` and `message_factory` will be used to unpack the value.
  // Both must outlive the resulting value and any of its shallow copies.
  // Otherwise the field is borrowed (no copying). Caller is responsible for
  // ensuring the resulting value and any derived values do not outlive the
  // input message.
  static Value WrapFieldUnsafe(
      ProtoWrapperTypeOptions wrapper_type_options,
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::FieldDescriptor* absl_nonnull field
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);

  // Returns an appropriate `Value` for the dynamic protobuf message repeated
  // field. If `field` in `message` is the well known type
  // `google.protobuf.Any`, `descriptor_pool` and `message_factory` will be used
  // to unpack the value. Both must outlive the resulting value and any of its
  // shallow copies.
  static Value WrapRepeatedField(
      int index,
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::FieldDescriptor* absl_nonnull field
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);

  // Returns an appropriate `Value` for the dynamic protobuf message repeated
  // field. If `field` in `message` is the well known type
  // `google.protobuf.Any`, `descriptor_pool` and `message_factory` will be used
  // to unpack the value. Both must outlive the resulting value and any of its
  // shallow copies.
  static Value WrapRepeatedFieldUnsafe(
      int index,
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::FieldDescriptor* absl_nonnull field
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);

  // Returns an appropriate `StringValue` for the dynamic protobuf message map
  // field key. The map field key must be a string or the behavior is undefined.
  static StringValue WrapMapFieldKeyString(
      const google::protobuf::MapKey& key,
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);

  // Returns an appropriate `Value` for the dynamic protobuf message map
  // field value. If `field` in `message`, which is `value`, is the well known
  // type `google.protobuf.Any`, `descriptor_pool` and `message_factory` will be
  // used to unpack the value. Both must outlive the resulting value and any of
  // its shallow copies.
  static Value WrapMapFieldValue(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::FieldDescriptor* absl_nonnull field
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);

  // Returns an appropriate `Value` for the dynamic protobuf message map
  // field value. If `field` in `message`, which is `value`, is the well known
  // type `google.protobuf.Any`, `descriptor_pool` and `message_factory` will be
  // used to unpack the value. Both must outlive the resulting value and any of
  // its shallow copies. Caller is responsible for ensuring the resulting value
  // and any derived values do not outlive the input message.
  static Value WrapMapFieldValueUnsafe(
      const google::protobuf::MapValueConstRef& value,
      const google::protobuf::Message* absl_nonnull message ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::FieldDescriptor* absl_nonnull field
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::MessageFactory* absl_nonnull message_factory
          ABSL_ATTRIBUTE_LIFETIME_BOUND,
      google::protobuf::Arena* absl_nonnull arena ABSL_ATTRIBUTE_LIFETIME_BOUND);

  Value() = default;
  Value(const Value&) = default;
  Value& operator=(const Value&) = default;
  Value(Value&& other) = default;
  Value& operator=(Value&&) = default;

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(const ListValue& value) : variant_(value.ToValueVariant()) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(ListValue&& value) : variant_(std::move(value).ToValueVariant()) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(const ListValue& value) {
    variant_ = value.ToValueVariant();
    return *this;
  }

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(ListValue&& value) {
    variant_ = std::move(value).ToValueVariant();
    return *this;
  }

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(const MapValue& value) : variant_(value.ToValueVariant()) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(MapValue&& value) : variant_(std::move(value).ToValueVariant()) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(const MapValue& value) {
    variant_ = value.ToValueVariant();
    return *this;
  }

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(MapValue&& value) {
    variant_ = std::move(value).ToValueVariant();
    return *this;
  }

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(const StructValue& value) : variant_(value.ToValueVariant()) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(StructValue&& value) : variant_(std::move(value).ToValueVariant()) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(const StructValue& value) {
    variant_ = value.ToValueVariant();
    return *this;
  }

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(StructValue&& value) {
    variant_ = std::move(value).ToValueVariant();
    return *this;
  }

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(const MessageValue& value) : variant_(value.ToValueVariant()) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(MessageValue&& value) : variant_(std::move(value).ToValueVariant()) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(const MessageValue& value) {
    variant_ = value.ToValueVariant();
    return *this;
  }

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(MessageValue&& value) {
    variant_ = std::move(value).ToValueVariant();
    return *this;
  }

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(const OptionalValue& value)
      : variant_(absl::in_place_type<OpaqueValue>,
                 static_cast<const OpaqueValue&>(value)) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(OptionalValue&& value)
      : variant_(absl::in_place_type<OpaqueValue>,
                 static_cast<OpaqueValue&&>(value)) {}

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(const OptionalValue& value) {
    variant_.Assign(static_cast<const OpaqueValue&>(value));
    return *this;
  }

  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(OptionalValue&& value) {
    variant_.Assign(static_cast<OpaqueValue&&>(value));
    return *this;
  }

  template <typename T,
            typename = std::enable_if_t<
                common_internal::IsValueAlternativeV<absl::remove_cvref_t<T>>>>
  // NOLINTNEXTLINE(google-explicit-constructor)
  Value(T&& alternative) noexcept
      : variant_(absl::in_place_type<absl::remove_cvref_t<T>>,
                 std::forward<T>(alternative)) {}

  template <typename T,
            typename = std::enable_if_t<
                common_internal::IsValueAlternativeV<absl::remove_cvref_t<T>>>>
  // NOLINTNEXTLINE(google-explicit-constructor)
  Value& operator=(T&& alternative) noexcept {
    variant_.Assign(std::forward<T>(alternative));
    return *this;
  }

  ValueKind kind() const { return variant_.kind(); }

  Type GetRuntimeType() const;

  absl::string_view GetTypeName() const;

  std::string DebugString() const;

  // `SerializeTo` serializes this value to `output`. If an error is returned,
  // `output` is in a valid but unspecified state. If this value does not
  // support serialization, `FAILED_PRECONDITION` is returned.
  absl::Status SerializeTo(
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
      google::protobuf::MessageFactory* absl_nonnull message_factory,
      google::protobuf::io::ZeroCopyOutputStream* absl_nonnull output) const;

  // `ConvertToJson` converts this value to its JSON representation. The
  // argument `json` **MUST** be an instance of `google.protobuf.Value` which is
  // can either be the generated message or a dynamic message. The descriptor
  // pool `descriptor_pool` and message factory `message_factory` are used to
  // deal with serialized messages and a few corners cases.
  absl::Status ConvertToJson(
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
      google::protobuf::MessageFactory* absl_nonnull message_factory,
      google::protobuf::Message* absl_nonnull json) const;

  // `ConvertToJsonArray` converts this value to its JSON representation if and
  // only if it can be represented as an array. The argument `json` **MUST** be
  // an instance of `google.protobuf.ListValue` which is can either be the
  // generated message or a dynamic message. The descriptor pool
  // `descriptor_pool` and message factory `message_factory` are used to deal
  // with serialized messages and a few corners cases.
  absl::Status ConvertToJsonArray(
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
      google::protobuf::MessageFactory* absl_nonnull message_factory,
      google::protobuf::Message* absl_nonnull json) const;

  // `ConvertToJsonArray` converts this value to its JSON representation if and
  // only if it can be represented as an object. The argument `json` **MUST** be
  // an instance of `google.protobuf.Struct` which is can either be the
  // generated message or a dynamic message. The descriptor pool
  // `descriptor_pool` and message factory `message_factory` are used to deal
  // with serialized messages and a few corners cases.
  absl::Status ConvertToJsonObject(
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
      google::protobuf::MessageFactory* absl_nonnull message_factory,
      google::protobuf::Message* absl_nonnull json) const;

  absl::Status Equal(const Value& other,
                     const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
                     google::protobuf::MessageFactory* absl_nonnull message_factory,
                     google::protobuf::Arena* absl_nonnull arena,
                     Value* absl_nonnull result) const;
  using ValueMixin::Equal;

  bool IsZeroValue() const;

  // Clones the value to another arena, if necessary, such that the lifetime of
  // the value is tied to the arena.
  Value Clone(google::protobuf::Arena* absl_nonnull arena) const;

  friend void swap(Value& lhs, Value& rhs) noexcept {
    using std::swap;
    swap(lhs.variant_, rhs.variant_);
  }

  friend std::ostream& operator<<(std::ostream& out, const Value& value);

  ABSL_DEPRECATED("Just use operator.()")
  Value* operator->() { return this; }

  ABSL_DEPRECATED("Just use operator.()")
  const Value* operator->() const { return this; }

  // Returns `true` if this value is an instance of a bool value.
  bool IsBool() const { return variant_.Is<BoolValue>(); }

  // Returns `true` if this value is an instance of a bool value and true.
  bool IsTrue() const { return IsBool() && GetBool().NativeValue(); }

  // Returns `true` if this value is an instance of a bool value and false.
  bool IsFalse() const { return IsBool() && !GetBool().NativeValue(); }

  // Returns `true` if this value is an instance of a bytes value.
  bool IsBytes() const { return variant_.Is<BytesValue>(); }

  // Returns `true` if this value is an instance of a double value.
  bool IsDouble() const { return variant_.Is<DoubleValue>(); }

  // Returns `true` if this value is an instance of a duration value.
  bool IsDuration() const { return variant_.Is<DurationValue>(); }

  // Returns `true` if this value is an instance of an error value.
  bool IsError() const { return variant_.Is<ErrorValue>(); }

  // Returns `true` if this value is an instance of an int value.
  bool IsInt() const { return variant_.Is<IntValue>(); }

  // Returns `true` if this value is an instance of a list value.
  bool IsList() const {
    return variant_.Is<common_internal::LegacyListValue>() ||
           variant_.Is<CustomListValue>() ||
           variant_.Is<ParsedRepeatedFieldValue>() ||
           variant_.Is<ParsedJsonListValue>();
  }

  // Returns `true` if this value is an instance of a map value.
  bool IsMap() const {
    return variant_.Is<common_internal::LegacyMapValue>() ||
           variant_.Is<CustomMapValue>() ||
           variant_.Is<ParsedMapFieldValue>() ||
           variant_.Is<ParsedJsonMapValue>();
  }

  // Returns `true` if this value is an instance of a message value. If `true`
  // is returned, it is implied that `IsStruct()` would also return true.
  bool IsMessage() const { return variant_.Is<ParsedMessageValue>(); }

  // Returns `true` if this value is an instance of a null value.
  bool IsNull() const { return variant_.Is<NullValue>(); }

  // Returns `true` if this value is an instance of an opaque value.
  bool IsOpaque() const { return variant_.Is<OpaqueValue>(); }

  // Returns `true` if this value is an instance of an optional value. If `true`
  // is returned, it is implied that `IsOpaque()` would also return true.
  bool IsOptional() const {
    if (const auto* alternative = variant_.As<OpaqueValue>();
        alternative != nullptr) {
      return alternative->IsOptional();
    }
    return false;
  }

  // Returns `true` if this value is an instance of a parsed JSON list value. If
  // `true` is returned, it is implied that `IsList()` would also return
  // true.
  bool IsParsedJsonList() const { return variant_.Is<ParsedJsonListValue>(); }

  // Returns `true` if this value is an instance of a parsed JSON map value. If
  // `true` is returned, it is implied that `IsMap()` would also return
  // true.
  bool IsParsedJsonMap() const { return variant_.Is<ParsedJsonMapValue>(); }

  // Returns `true` if this value is an instance of a custom list value. If
  // `true` is returned, it is implied that `IsList()` would also return
  // true.
  bool IsCustomList() const { return variant_.Is<CustomListValue>(); }

  // Returns `true` if this value is an instance of a custom map value. If
  // `true` is returned, it is implied that `IsMap()` would also return
  // true.
  bool IsCustomMap() const { return variant_.Is<CustomMapValue>(); }

  // Returns `true` if this value is an instance of a parsed map field value. If
  // `true` is returned, it is implied that `IsMap()` would also return
  // true.
  bool IsParsedMapField() const { return variant_.Is<ParsedMapFieldValue>(); }

  // Returns `true` if this value is an instance of a parsed message value. If
  // `true` is returned, it is implied that `IsMessage()` would also return
  // true.
  bool IsParsedMessage() const { return variant_.Is<ParsedMessageValue>(); }

  // Returns `true` if this value is an instance of a parsed repeated field
  // value. If `true` is returned, it is implied that `IsList()` would also
  // return true.
  bool IsParsedRepeatedField() const {
    return variant_.Is<ParsedRepeatedFieldValue>();
  }

  // Returns `true` if this value is an instance of a custom struct value. If
  // `true` is returned, it is implied that `IsStruct()` would also return
  // true.
  bool IsCustomStruct() const { return variant_.Is<CustomStructValue>(); }

  // Returns `true` if this value is an instance of a string value.
  bool IsString() const { return variant_.Is<StringValue>(); }

  // Returns `true` if this value is an instance of a struct value.
  bool IsStruct() const {
    return variant_.Is<common_internal::LegacyStructValue>() ||
           variant_.Is<CustomStructValue>() ||
           variant_.Is<ParsedMessageValue>();
  }

  // Returns `true` if this value is an instance of a timestamp value.
  bool IsTimestamp() const { return variant_.Is<TimestampValue>(); }

  // Returns `true` if this value is an instance of a type value.
  bool IsType() const { return variant_.Is<TypeValue>(); }

  // Returns `true` if this value is an instance of a uint value.
  bool IsUint() const { return variant_.Is<UintValue>(); }

  // Returns `true` if this value is an instance of an unknown value.
  bool IsUnknown() const { return variant_.Is<UnknownValue>(); }

  // Convenience method for use with template metaprogramming. See
  // `IsBool()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<BoolValue, T>, bool> Is() const {
    return IsBool();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsBytes()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<BytesValue, T>, bool> Is() const {
    return IsBytes();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsDouble()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<DoubleValue, T>, bool> Is() const {
    return IsDouble();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsDuration()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<DurationValue, T>, bool> Is() const {
    return IsDuration();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsError()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<ErrorValue, T>, bool> Is() const {
    return IsError();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsInt()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<IntValue, T>, bool> Is() const {
    return IsInt();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsList()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<ListValue, T>, bool> Is() const {
    return IsList();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsMap()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<MapValue, T>, bool> Is() const {
    return IsMap();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsMessage()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<MessageValue, T>, bool> Is() const {
    return IsMessage();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsNull()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<NullValue, T>, bool> Is() const {
    return IsNull();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsOpaque()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<OpaqueValue, T>, bool> Is() const {
    return IsOpaque();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsOptional()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<OptionalValue, T>, bool> Is() const {
    return IsOptional();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsParsedJsonList()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>, bool> Is() const {
    return IsParsedJsonList();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsParsedJsonMap()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>, bool> Is() const {
    return IsParsedJsonMap();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsCustomList()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomListValue, T>, bool> Is() const {
    return IsCustomList();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsCustomMap()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomMapValue, T>, bool> Is() const {
    return IsCustomMap();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsParsedMapField()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>, bool> Is() const {
    return IsParsedMapField();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsParsedMessage()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMessageValue, T>, bool> Is() const {
    return IsParsedMessage();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsParsedRepeatedField()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>, bool> Is()
      const {
    return IsParsedRepeatedField();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsParsedStruct()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomStructValue, T>, bool> Is() const {
    return IsCustomStruct();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsString()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<StringValue, T>, bool> Is() const {
    return IsString();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsStruct()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<StructValue, T>, bool> Is() const {
    return IsStruct();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsTimestamp()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<TimestampValue, T>, bool> Is() const {
    return IsTimestamp();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsType()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<TypeValue, T>, bool> Is() const {
    return IsType();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsUint()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<UintValue, T>, bool> Is() const {
    return IsUint();
  }

  // Convenience method for use with template metaprogramming. See
  // `IsUnknown()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<UnknownValue, T>, bool> Is() const {
    return IsUnknown();
  }

  // Performs a checked cast from a value to a bool value,
  // returning a non-empty optional with either a value or reference to the
  // bool value. Otherwise an empty optional is returned.
  absl::optional<BoolValue> AsBool() const {
    if (const auto* alternative = variant_.As<BoolValue>();
        alternative != nullptr) {
      return *alternative;
    }
    return absl::nullopt;
  }

  // Performs a checked cast from a value to a bytes value,
  // returning a non-empty optional with either a value or reference to the
  // bytes value. Otherwise an empty optional is returned.
  optional_ref<const BytesValue> AsBytes() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsBytes();
  }
  optional_ref<const BytesValue> AsBytes() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<BytesValue> AsBytes() &&;
  absl::optional<BytesValue> AsBytes() const&& {
    return common_internal::AsOptional(AsBytes());
  }

  // Performs a checked cast from a value to a double value,
  // returning a non-empty optional with either a value or reference to the
  // double value. Otherwise an empty optional is returned.
  absl::optional<DoubleValue> AsDouble() const;

  // Performs a checked cast from a value to a duration value,
  // returning a non-empty optional with either a value or reference to the
  // duration value. Otherwise an empty optional is returned.
  absl::optional<DurationValue> AsDuration() const;

  // Performs a checked cast from a value to an error value,
  // returning a non-empty optional with either a value or reference to the
  // error value. Otherwise an empty optional is returned.
  optional_ref<const ErrorValue> AsError() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsError();
  }
  optional_ref<const ErrorValue> AsError() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<ErrorValue> AsError() &&;
  absl::optional<ErrorValue> AsError() const&& {
    return common_internal::AsOptional(AsError());
  }

  // Performs a checked cast from a value to an int value,
  // returning a non-empty optional with either a value or reference to the
  // int value. Otherwise an empty optional is returned.
  absl::optional<IntValue> AsInt() const;

  // Performs a checked cast from a value to a list value,
  // returning a non-empty optional with either a value or reference to the
  // list value. Otherwise an empty optional is returned.
  absl::optional<ListValue> AsList() & { return std::as_const(*this).AsList(); }
  absl::optional<ListValue> AsList() const&;
  absl::optional<ListValue> AsList() &&;
  absl::optional<ListValue> AsList() const&& {
    return common_internal::AsOptional(AsList());
  }

  // Performs a checked cast from a value to a map value,
  // returning a non-empty optional with either a value or reference to the
  // map value. Otherwise an empty optional is returned.
  absl::optional<MapValue> AsMap() & { return std::as_const(*this).AsMap(); }
  absl::optional<MapValue> AsMap() const&;
  absl::optional<MapValue> AsMap() &&;
  absl::optional<MapValue> AsMap() const&& {
    return common_internal::AsOptional(AsMap());
  }

  // Performs a checked cast from a value to a message value,
  // returning a non-empty optional with either a value or reference to the
  // message value. Otherwise an empty optional is returned.
  absl::optional<MessageValue> AsMessage() & {
    return std::as_const(*this).AsMessage();
  }
  absl::optional<MessageValue> AsMessage() const&;
  absl::optional<MessageValue> AsMessage() &&;
  absl::optional<MessageValue> AsMessage() const&& {
    return common_internal::AsOptional(AsMessage());
  }

  // Performs a checked cast from a value to a null value,
  // returning a non-empty optional with either a value or reference to the
  // null value. Otherwise an empty optional is returned.
  absl::optional<NullValue> AsNull() const;

  // Performs a checked cast from a value to an opaque value,
  // returning a non-empty optional with either a value or reference to the
  // opaque value. Otherwise an empty optional is returned.
  optional_ref<const OpaqueValue> AsOpaque() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsOpaque();
  }
  optional_ref<const OpaqueValue> AsOpaque()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<OpaqueValue> AsOpaque() &&;
  absl::optional<OpaqueValue> AsOpaque() const&& {
    return common_internal::AsOptional(AsOpaque());
  }

  // Performs a checked cast from a value to an optional value,
  // returning a non-empty optional with either a value or reference to the
  // optional value. Otherwise an empty optional is returned.
  optional_ref<const OptionalValue> AsOptional() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsOptional();
  }
  optional_ref<const OptionalValue> AsOptional()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<OptionalValue> AsOptional() &&;
  absl::optional<OptionalValue> AsOptional() const&& {
    return common_internal::AsOptional(AsOptional());
  }

  // Performs a checked cast from a value to a parsed JSON list value,
  // returning a non-empty optional with either a value or reference to the
  // parsed message value. Otherwise an empty optional is returned.
  optional_ref<const ParsedJsonListValue> AsParsedJsonList() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsParsedJsonList();
  }
  optional_ref<const ParsedJsonListValue> AsParsedJsonList()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<ParsedJsonListValue> AsParsedJsonList() &&;
  absl::optional<ParsedJsonListValue> AsParsedJsonList() const&& {
    return common_internal::AsOptional(AsParsedJsonList());
  }

  // Performs a checked cast from a value to a parsed JSON map value,
  // returning a non-empty optional with either a value or reference to the
  // parsed message value. Otherwise an empty optional is returned.
  optional_ref<const ParsedJsonMapValue> AsParsedJsonMap() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsParsedJsonMap();
  }
  optional_ref<const ParsedJsonMapValue> AsParsedJsonMap()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<ParsedJsonMapValue> AsParsedJsonMap() &&;
  absl::optional<ParsedJsonMapValue> AsParsedJsonMap() const&& {
    return common_internal::AsOptional(AsParsedJsonMap());
  }

  // Performs a checked cast from a value to a custom list value,
  // returning a non-empty optional with either a value or reference to the
  // custom list value. Otherwise an empty optional is returned.
  optional_ref<const CustomListValue> AsCustomList() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsCustomList();
  }
  optional_ref<const CustomListValue> AsCustomList()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<CustomListValue> AsCustomList() &&;
  absl::optional<CustomListValue> AsCustomList() const&& {
    return common_internal::AsOptional(AsCustomList());
  }

  // Performs a checked cast from a value to a custom map value,
  // returning a non-empty optional with either a value or reference to the
  // custom map value. Otherwise an empty optional is returned.
  optional_ref<const CustomMapValue> AsCustomMap() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsCustomMap();
  }
  optional_ref<const CustomMapValue> AsCustomMap()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<CustomMapValue> AsCustomMap() &&;
  absl::optional<CustomMapValue> AsCustomMap() const&& {
    return common_internal::AsOptional(AsCustomMap());
  }

  // Performs a checked cast from a value to a parsed map field value,
  // returning a non-empty optional with either a value or reference to the
  // parsed map field value. Otherwise an empty optional is returned.
  optional_ref<const ParsedMapFieldValue> AsParsedMapField() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsParsedMapField();
  }
  optional_ref<const ParsedMapFieldValue> AsParsedMapField()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<ParsedMapFieldValue> AsParsedMapField() &&;
  absl::optional<ParsedMapFieldValue> AsParsedMapField() const&& {
    return common_internal::AsOptional(AsParsedMapField());
  }

  // Performs a checked cast from a value to a parsed message value,
  // returning a non-empty optional with either a value or reference to the
  // parsed message value. Otherwise an empty optional is returned.
  optional_ref<const ParsedMessageValue> AsParsedMessage() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsParsedMessage();
  }
  optional_ref<const ParsedMessageValue> AsParsedMessage()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<ParsedMessageValue> AsParsedMessage() &&;
  absl::optional<ParsedMessageValue> AsParsedMessage() const&& {
    return common_internal::AsOptional(AsParsedMessage());
  }

  // Performs a checked cast from a value to a parsed repeated field value,
  // returning a non-empty optional with either a value or reference to the
  // parsed repeated field value. Otherwise an empty optional is returned.
  optional_ref<const ParsedRepeatedFieldValue> AsParsedRepeatedField() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsParsedRepeatedField();
  }
  optional_ref<const ParsedRepeatedFieldValue> AsParsedRepeatedField()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<ParsedRepeatedFieldValue> AsParsedRepeatedField() &&;
  absl::optional<ParsedRepeatedFieldValue> AsParsedRepeatedField() const&& {
    return common_internal::AsOptional(AsParsedRepeatedField());
  }

  // Performs a checked cast from a value to a custom struct value,
  // returning a non-empty optional with either a value or reference to the
  // custom struct value. Otherwise an empty optional is returned.
  optional_ref<const CustomStructValue> AsCustomStruct() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsCustomStruct();
  }
  optional_ref<const CustomStructValue> AsCustomStruct()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<CustomStructValue> AsCustomStruct() &&;
  absl::optional<CustomStructValue> AsCustomStruct() const&& {
    return common_internal::AsOptional(AsCustomStruct());
  }

  // Performs a checked cast from a value to a string value,
  // returning a non-empty optional with either a value or reference to the
  // string value. Otherwise an empty optional is returned.
  optional_ref<const StringValue> AsString() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsString();
  }
  optional_ref<const StringValue> AsString()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<StringValue> AsString() &&;
  absl::optional<StringValue> AsString() const&& {
    return common_internal::AsOptional(AsString());
  }

  // Performs a checked cast from a value to a struct value,
  // returning a non-empty optional with either a value or reference to the
  // struct value. Otherwise an empty optional is returned.
  absl::optional<StructValue> AsStruct() & {
    return std::as_const(*this).AsStruct();
  }
  absl::optional<StructValue> AsStruct() const&;
  absl::optional<StructValue> AsStruct() &&;
  absl::optional<StructValue> AsStruct() const&& {
    return common_internal::AsOptional(AsStruct());
  }

  // Performs a checked cast from a value to a timestamp value,
  // returning a non-empty optional with either a value or reference to the
  // timestamp value. Otherwise an empty optional is returned.
  absl::optional<TimestampValue> AsTimestamp() const;

  // Performs a checked cast from a value to a type value,
  // returning a non-empty optional with either a value or reference to the
  // type value. Otherwise an empty optional is returned.
  optional_ref<const TypeValue> AsType() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsType();
  }
  optional_ref<const TypeValue> AsType() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<TypeValue> AsType() &&;
  absl::optional<TypeValue> AsType() const&& {
    return common_internal::AsOptional(AsType());
  }

  // Performs a checked cast from a value to an uint value,
  // returning a non-empty optional with either a value or reference to the
  // uint value. Otherwise an empty optional is returned.
  absl::optional<UintValue> AsUint() const;

  // Performs a checked cast from a value to an unknown value,
  // returning a non-empty optional with either a value or reference to the
  // unknown value. Otherwise an empty optional is returned.
  optional_ref<const UnknownValue> AsUnknown() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).AsUnknown();
  }
  optional_ref<const UnknownValue> AsUnknown()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  absl::optional<UnknownValue> AsUnknown() &&;
  absl::optional<UnknownValue> AsUnknown() const&& {
    return common_internal::AsOptional(AsUnknown());
  }

  // Convenience method for use with template metaprogramming. See
  // `AsBool()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<BoolValue, T>, absl::optional<BoolValue>>
  As() & {
    return AsBool();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BoolValue, T>, absl::optional<BoolValue>> As()
      const& {
    return AsBool();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BoolValue, T>, absl::optional<BoolValue>>
  As() && {
    return AsBool();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BoolValue, T>, absl::optional<BoolValue>> As()
      const&& {
    return AsBool();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsBytes()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<BytesValue, T>,
                       optional_ref<const BytesValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsBytes();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BytesValue, T>,
                   optional_ref<const BytesValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsBytes();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BytesValue, T>, absl::optional<BytesValue>>
  As() && {
    return std::move(*this).AsBytes();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BytesValue, T>, absl::optional<BytesValue>>
  As() const&& {
    return std::move(*this).AsBytes();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsDouble()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<DoubleValue, T>, absl::optional<DoubleValue>>
  As() & {
    return AsDouble();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DoubleValue, T>, absl::optional<DoubleValue>>
  As() const& {
    return AsDouble();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DoubleValue, T>, absl::optional<DoubleValue>>
  As() && {
    return AsDouble();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DoubleValue, T>, absl::optional<DoubleValue>>
  As() const&& {
    return AsDouble();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsDuration()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<DurationValue, T>,
                   absl::optional<DurationValue>>
  As() & {
    return AsDuration();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DurationValue, T>,
                   absl::optional<DurationValue>>
  As() const& {
    return AsDuration();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DurationValue, T>,
                   absl::optional<DurationValue>>
  As() && {
    return AsDuration();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DurationValue, T>,
                   absl::optional<DurationValue>>
  As() const&& {
    return AsDuration();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsError()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ErrorValue, T>,
                       optional_ref<const ErrorValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsError();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ErrorValue, T>,
                   optional_ref<const ErrorValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsError();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ErrorValue, T>, absl::optional<ErrorValue>>
  As() && {
    return std::move(*this).AsError();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ErrorValue, T>, absl::optional<ErrorValue>>
  As() const&& {
    return std::move(*this).AsError();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsInt()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<IntValue, T>, absl::optional<IntValue>>
  As() & {
    return AsInt();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<IntValue, T>, absl::optional<IntValue>> As()
      const& {
    return AsInt();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<IntValue, T>, absl::optional<IntValue>>
  As() && {
    return AsInt();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<IntValue, T>, absl::optional<IntValue>> As()
      const&& {
    return AsInt();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsList()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<ListValue, T>, absl::optional<ListValue>>
  As() & {
    return AsList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ListValue, T>, absl::optional<ListValue>> As()
      const& {
    return AsList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ListValue, T>, absl::optional<ListValue>>
  As() && {
    return std::move(*this).AsList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ListValue, T>, absl::optional<ListValue>> As()
      const&& {
    return std::move(*this).AsList();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsMap()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<MapValue, T>, absl::optional<MapValue>>
  As() & {
    return AsMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MapValue, T>, absl::optional<MapValue>> As()
      const& {
    return AsMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MapValue, T>, absl::optional<MapValue>>
  As() && {
    return std::move(*this).AsMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MapValue, T>, absl::optional<MapValue>> As()
      const&& {
    return std::move(*this).AsMap();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsMessage()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<MessageValue, T>,
                   absl::optional<MessageValue>>
  As() & {
    return AsMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MessageValue, T>,
                   absl::optional<MessageValue>>
  As() const& {
    return AsMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MessageValue, T>,
                   absl::optional<MessageValue>>
  As() && {
    return std::move(*this).AsMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MessageValue, T>,
                   absl::optional<MessageValue>>
  As() const&& {
    return std::move(*this).AsMessage();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsNull()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<NullValue, T>, absl::optional<NullValue>>
  As() & {
    return AsNull();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<NullValue, T>, absl::optional<NullValue>> As()
      const& {
    return AsNull();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<NullValue, T>, absl::optional<NullValue>>
  As() && {
    return AsNull();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<NullValue, T>, absl::optional<NullValue>> As()
      const&& {
    return AsNull();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsOpaque()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<OpaqueValue, T>,
                       optional_ref<const OpaqueValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsOpaque();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OpaqueValue, T>,
                   optional_ref<const OpaqueValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsOpaque();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OpaqueValue, T>, absl::optional<OpaqueValue>>
  As() && {
    return std::move(*this).AsOpaque();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OpaqueValue, T>, absl::optional<OpaqueValue>>
  As() const&& {
    return std::move(*this).AsOpaque();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsOptional()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<OptionalValue, T>,
                       optional_ref<const OptionalValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsOptional();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OptionalValue, T>,
                   optional_ref<const OptionalValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsOptional();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OptionalValue, T>,
                   absl::optional<OptionalValue>>
  As() && {
    return std::move(*this).AsOptional();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OptionalValue, T>,
                   absl::optional<OptionalValue>>
  As() const&& {
    return std::move(*this).AsOptional();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsParsedJsonList()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>,
                       optional_ref<const ParsedJsonListValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedJsonList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>,
                   optional_ref<const ParsedJsonListValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedJsonList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>,
                   absl::optional<ParsedJsonListValue>>
  As() && {
    return std::move(*this).AsParsedJsonList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>,
                   absl::optional<ParsedJsonListValue>>
  As() const&& {
    return std::move(*this).AsParsedJsonList();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsParsedJsonMap()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>,
                       optional_ref<const ParsedJsonMapValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedJsonMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>,
                   optional_ref<const ParsedJsonMapValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedJsonMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>,
                   absl::optional<ParsedJsonMapValue>>
  As() && {
    return std::move(*this).AsParsedJsonMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>,
                   absl::optional<ParsedJsonMapValue>>
  As() const&& {
    return std::move(*this).AsParsedJsonMap();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsCustomList()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<CustomListValue, T>,
                       optional_ref<const CustomListValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsCustomList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomListValue, T>,
                   optional_ref<const CustomListValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsCustomList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomListValue, T>,
                   absl::optional<CustomListValue>>
  As() && {
    return std::move(*this).AsCustomList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomListValue, T>,
                   absl::optional<CustomListValue>>
  As() const&& {
    return std::move(*this).AsCustomList();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsCustomMap()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<CustomMapValue, T>,
                       optional_ref<const CustomMapValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsCustomMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomMapValue, T>,
                   optional_ref<const CustomMapValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsCustomMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomMapValue, T>,
                   absl::optional<CustomMapValue>>
  As() && {
    return std::move(*this).AsCustomMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomMapValue, T>,
                   absl::optional<CustomMapValue>>
  As() const&& {
    return std::move(*this).AsCustomMap();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsParsedMapField()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>,
                       optional_ref<const ParsedMapFieldValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedMapField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>,
                   optional_ref<const ParsedMapFieldValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedMapField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>,
                   absl::optional<ParsedMapFieldValue>>
  As() && {
    return std::move(*this).AsParsedMapField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>,
                   absl::optional<ParsedMapFieldValue>>
  As() const&& {
    return std::move(*this).AsParsedMapField();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsParsedMessage()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedMessageValue, T>,
                       optional_ref<const ParsedMessageValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMessageValue, T>,
                   optional_ref<const ParsedMessageValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMessageValue, T>,
                   absl::optional<ParsedMessageValue>>
  As() && {
    return std::move(*this).AsParsedMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMessageValue, T>,
                   absl::optional<ParsedMessageValue>>
  As() const&& {
    return std::move(*this).AsParsedMessage();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsParsedRepeatedField()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>,
                       optional_ref<const ParsedRepeatedFieldValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedRepeatedField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>,
                   optional_ref<const ParsedRepeatedFieldValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsParsedRepeatedField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>,
                   absl::optional<ParsedRepeatedFieldValue>>
  As() && {
    return std::move(*this).AsParsedRepeatedField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>,
                   absl::optional<ParsedRepeatedFieldValue>>
  As() const&& {
    return std::move(*this).AsParsedRepeatedField();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsCustomStruct()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<CustomStructValue, T>,
                       optional_ref<const CustomStructValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsCustomStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomStructValue, T>,
                   optional_ref<const CustomStructValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsCustomStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomStructValue, T>,
                   absl::optional<CustomStructValue>>
  As() && {
    return std::move(*this).AsCustomStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomStructValue, T>,
                   absl::optional<CustomStructValue>>
  As() const&& {
    return std::move(*this).AsCustomStruct();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsString()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<StringValue, T>,
                       optional_ref<const StringValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsString();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StringValue, T>,
                   optional_ref<const StringValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsString();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StringValue, T>, absl::optional<StringValue>>
  As() && {
    return std::move(*this).AsString();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StringValue, T>, absl::optional<StringValue>>
  As() const&& {
    return std::move(*this).AsString();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsStruct()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<StructValue, T>, absl::optional<StructValue>>
  As() & {
    return AsStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StructValue, T>, absl::optional<StructValue>>
  As() const& {
    return AsStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StructValue, T>, absl::optional<StructValue>>
  As() && {
    return std::move(*this).AsStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StructValue, T>, absl::optional<StructValue>>
  As() const&& {
    return std::move(*this).AsStruct();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsTimestamp()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<TimestampValue, T>,
                   absl::optional<TimestampValue>>
  As() & {
    return AsTimestamp();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TimestampValue, T>,
                   absl::optional<TimestampValue>>
  As() const& {
    return AsTimestamp();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TimestampValue, T>,
                   absl::optional<TimestampValue>>
  As() && {
    return AsTimestamp();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TimestampValue, T>,
                   absl::optional<TimestampValue>>
  As() const&& {
    return AsTimestamp();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsType()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<TypeValue, T>,
                       optional_ref<const TypeValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsType();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TypeValue, T>, optional_ref<const TypeValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsType();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TypeValue, T>, absl::optional<TypeValue>>
  As() && {
    return std::move(*this).AsType();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TypeValue, T>, absl::optional<TypeValue>> As()
      const&& {
    return std::move(*this).AsType();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsUint()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<UintValue, T>, absl::optional<UintValue>>
  As() & {
    return AsUint();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UintValue, T>, absl::optional<UintValue>> As()
      const& {
    return AsUint();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UintValue, T>, absl::optional<UintValue>>
  As() && {
    return AsUint();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UintValue, T>, absl::optional<UintValue>> As()
      const&& {
    return AsUint();
  }

  // Convenience method for use with template metaprogramming. See
  // `AsUnknown()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<UnknownValue, T>,
                       optional_ref<const UnknownValue>>
      As() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsUnknown();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UnknownValue, T>,
                   optional_ref<const UnknownValue>>
  As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return AsUnknown();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UnknownValue, T>,
                   absl::optional<UnknownValue>>
  As() && {
    return std::move(*this).AsUnknown();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UnknownValue, T>,
                   absl::optional<UnknownValue>>
  As() const&& {
    return std::move(*this).AsUnknown();
  }

  // Performs an unchecked cast from a value to a bool value. In
  // debug builds a best effort is made to crash. If `IsBool()` would return
  // false, calling this method is undefined behavior.
  BoolValue GetBool() const {
    ABSL_DCHECK(IsBool()) << *this;
    return variant_.Get<BoolValue>();
  }

  // Performs an unchecked cast from a value to a bytes value. In
  // debug builds a best effort is made to crash. If `IsBytes()` would return
  // false, calling this method is undefined behavior.
  const BytesValue& GetBytes() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetBytes();
  }
  const BytesValue& GetBytes() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  BytesValue GetBytes() &&;
  BytesValue GetBytes() const&& { return GetBytes(); }

  // Performs an unchecked cast from a value to a double value. In
  // debug builds a best effort is made to crash. If `IsDouble()` would return
  // false, calling this method is undefined behavior.
  DoubleValue GetDouble() const;

  // Performs an unchecked cast from a value to a duration value. In
  // debug builds a best effort is made to crash. If `IsDuration()` would return
  // false, calling this method is undefined behavior.
  DurationValue GetDuration() const;

  // Performs an unchecked cast from a value to an error value. In
  // debug builds a best effort is made to crash. If `IsError()` would return
  // false, calling this method is undefined behavior.
  const ErrorValue& GetError() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetError();
  }
  const ErrorValue& GetError() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  ErrorValue GetError() &&;
  ErrorValue GetError() const&& { return GetError(); }

  // Performs an unchecked cast from a value to an int value. In
  // debug builds a best effort is made to crash. If `IsInt()` would return
  // false, calling this method is undefined behavior.
  IntValue GetInt() const;

  // Performs an unchecked cast from a value to a list value. In
  // debug builds a best effort is made to crash. If `IsList()` would return
  // false, calling this method is undefined behavior.
  ListValue GetList() & { return std::as_const(*this).GetList(); }
  ListValue GetList() const&;
  ListValue GetList() &&;
  ListValue GetList() const&& { return GetList(); }

  // Performs an unchecked cast from a value to a map value. In
  // debug builds a best effort is made to crash. If `IsMap()` would return
  // false, calling this method is undefined behavior.
  MapValue GetMap() & { return std::as_const(*this).GetMap(); }
  MapValue GetMap() const&;
  MapValue GetMap() &&;
  MapValue GetMap() const&& { return GetMap(); }

  // Performs an unchecked cast from a value to a message value. In
  // debug builds a best effort is made to crash. If `IsMessage()` would return
  // false, calling this method is undefined behavior.
  MessageValue GetMessage() & { return std::as_const(*this).GetMessage(); }
  MessageValue GetMessage() const&;
  MessageValue GetMessage() &&;
  MessageValue GetMessage() const&& { return GetMessage(); }

  // Performs an unchecked cast from a value to a null value. In
  // debug builds a best effort is made to crash. If `IsNull()` would return
  // false, calling this method is undefined behavior.
  NullValue GetNull() const;

  // Performs an unchecked cast from a value to an opaque value. In
  // debug builds a best effort is made to crash. If `IsOpaque()` would return
  // false, calling this method is undefined behavior.
  const OpaqueValue& GetOpaque() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetOpaque();
  }
  const OpaqueValue& GetOpaque() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  OpaqueValue GetOpaque() &&;
  OpaqueValue GetOpaque() const&& { return GetOpaque(); }

  // Performs an unchecked cast from a value to an optional value. In
  // debug builds a best effort is made to crash. If `IsOptional()` would return
  // false, calling this method is undefined behavior.
  const OptionalValue& GetOptional() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetOptional();
  }
  const OptionalValue& GetOptional() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  OptionalValue GetOptional() &&;
  OptionalValue GetOptional() const&& { return GetOptional(); }

  // Performs an unchecked cast from a value to a parsed message value. In
  // debug builds a best effort is made to crash. If `IsParsedJsonList()` would
  // return false, calling this method is undefined behavior.
  const ParsedJsonListValue& GetParsedJsonList() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetParsedJsonList();
  }
  const ParsedJsonListValue& GetParsedJsonList()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  ParsedJsonListValue GetParsedJsonList() &&;
  ParsedJsonListValue GetParsedJsonList() const&& {
    return GetParsedJsonList();
  }

  // Performs an unchecked cast from a value to a parsed message value. In
  // debug builds a best effort is made to crash. If `IsParsedJsonMap()` would
  // return false, calling this method is undefined behavior.
  const ParsedJsonMapValue& GetParsedJsonMap() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetParsedJsonMap();
  }
  const ParsedJsonMapValue& GetParsedJsonMap()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  ParsedJsonMapValue GetParsedJsonMap() &&;
  ParsedJsonMapValue GetParsedJsonMap() const&& { return GetParsedJsonMap(); }

  // Performs an unchecked cast from a value to a custom list value. In
  // debug builds a best effort is made to crash. If `IsCustomList()` would
  // return false, calling this method is undefined behavior.
  const CustomListValue& GetCustomList() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetCustomList();
  }
  const CustomListValue& GetCustomList() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  CustomListValue GetCustomList() &&;
  CustomListValue GetCustomList() const&& { return GetCustomList(); }

  // Performs an unchecked cast from a value to a custom map value. In
  // debug builds a best effort is made to crash. If `IsCustomMap()` would
  // return false, calling this method is undefined behavior.
  const CustomMapValue& GetCustomMap() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetCustomMap();
  }
  const CustomMapValue& GetCustomMap() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  CustomMapValue GetCustomMap() &&;
  CustomMapValue GetCustomMap() const&& { return GetCustomMap(); }

  // Performs an unchecked cast from a value to a parsed map field value. In
  // debug builds a best effort is made to crash. If `IsParsedMapField()` would
  // return false, calling this method is undefined behavior.
  const ParsedMapFieldValue& GetParsedMapField() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetParsedMapField();
  }
  const ParsedMapFieldValue& GetParsedMapField()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  ParsedMapFieldValue GetParsedMapField() &&;
  ParsedMapFieldValue GetParsedMapField() const&& {
    return GetParsedMapField();
  }

  // Performs an unchecked cast from a value to a parsed message value. In
  // debug builds a best effort is made to crash. If `IsParsedMessage()` would
  // return false, calling this method is undefined behavior.
  const ParsedMessageValue& GetParsedMessage() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetParsedMessage();
  }
  const ParsedMessageValue& GetParsedMessage()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  ParsedMessageValue GetParsedMessage() &&;
  ParsedMessageValue GetParsedMessage() const&& { return GetParsedMessage(); }

  // Performs an unchecked cast from a value to a parsed repeated field value.
  // In debug builds a best effort is made to crash. If
  // `IsParsedRepeatedField()` would return false, calling this method is
  // undefined behavior.
  const ParsedRepeatedFieldValue& GetParsedRepeatedField() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetParsedRepeatedField();
  }
  const ParsedRepeatedFieldValue& GetParsedRepeatedField()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  ParsedRepeatedFieldValue GetParsedRepeatedField() &&;
  ParsedRepeatedFieldValue GetParsedRepeatedField() const&& {
    return GetParsedRepeatedField();
  }

  // Performs an unchecked cast from a value to a custom struct value. In
  // debug builds a best effort is made to crash. If `IsCustomStruct()` would
  // return false, calling this method is undefined behavior.
  const CustomStructValue& GetCustomStruct() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetCustomStruct();
  }
  const CustomStructValue& GetCustomStruct()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  CustomStructValue GetCustomStruct() &&;
  CustomStructValue GetCustomStruct() const&& { return GetCustomStruct(); }

  // Performs an unchecked cast from a value to a string value. In
  // debug builds a best effort is made to crash. If `IsString()` would return
  // false, calling this method is undefined behavior.
  const StringValue& GetString() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetString();
  }
  const StringValue& GetString() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  StringValue GetString() &&;
  StringValue GetString() const&& { return GetString(); }

  // Performs an unchecked cast from a value to a struct value. In
  // debug builds a best effort is made to crash. If `IsStruct()` would return
  // false, calling this method is undefined behavior.
  StructValue GetStruct() & { return std::as_const(*this).GetStruct(); }
  StructValue GetStruct() const&;
  StructValue GetStruct() &&;
  StructValue GetStruct() const&& { return GetStruct(); }

  // Performs an unchecked cast from a value to a timestamp value. In
  // debug builds a best effort is made to crash. If `IsTimestamp()` would
  // return false, calling this method is undefined behavior.
  TimestampValue GetTimestamp() const;

  // Performs an unchecked cast from a value to a type value. In
  // debug builds a best effort is made to crash. If `IsType()` would return
  // false, calling this method is undefined behavior.
  const TypeValue& GetType() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetType();
  }
  const TypeValue& GetType() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  TypeValue GetType() &&;
  TypeValue GetType() const&& { return GetType(); }

  // Performs an unchecked cast from a value to an uint value. In
  // debug builds a best effort is made to crash. If `IsUint()` would return
  // false, calling this method is undefined behavior.
  UintValue GetUint() const;

  // Performs an unchecked cast from a value to an unknown value. In
  // debug builds a best effort is made to crash. If `IsUnknown()` would return
  // false, calling this method is undefined behavior.
  const UnknownValue& GetUnknown() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return std::as_const(*this).GetUnknown();
  }
  const UnknownValue& GetUnknown() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
  UnknownValue GetUnknown() &&;
  UnknownValue GetUnknown() const&& { return GetUnknown(); }

  // Convenience method for use with template metaprogramming. See
  // `GetBool()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<BoolValue, T>, BoolValue> Get() & {
    return GetBool();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BoolValue, T>, BoolValue> Get() const& {
    return GetBool();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BoolValue, T>, BoolValue> Get() && {
    return GetBool();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BoolValue, T>, BoolValue> Get() const&& {
    return GetBool();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetBytes()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<BytesValue, T>, const BytesValue&> Get() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetBytes();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BytesValue, T>, const BytesValue&> Get()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetBytes();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BytesValue, T>, BytesValue> Get() && {
    return std::move(*this).GetBytes();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<BytesValue, T>, BytesValue> Get() const&& {
    return std::move(*this).GetBytes();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetDouble()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<DoubleValue, T>, DoubleValue> Get() & {
    return GetDouble();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DoubleValue, T>, DoubleValue> Get() const& {
    return GetDouble();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DoubleValue, T>, DoubleValue> Get() && {
    return GetDouble();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DoubleValue, T>, DoubleValue> Get() const&& {
    return GetDouble();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetDuration()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<DurationValue, T>, DurationValue> Get() & {
    return GetDuration();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DurationValue, T>, DurationValue> Get()
      const& {
    return GetDuration();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DurationValue, T>, DurationValue> Get() && {
    return GetDuration();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<DurationValue, T>, DurationValue> Get()
      const&& {
    return GetDuration();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetError()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ErrorValue, T>, const ErrorValue&> Get() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetError();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ErrorValue, T>, const ErrorValue&> Get()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetError();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ErrorValue, T>, ErrorValue> Get() && {
    return std::move(*this).GetError();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ErrorValue, T>, ErrorValue> Get() const&& {
    return std::move(*this).GetError();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetInt()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<IntValue, T>, IntValue> Get() & {
    return GetInt();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<IntValue, T>, IntValue> Get() const& {
    return GetInt();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<IntValue, T>, IntValue> Get() && {
    return GetInt();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<IntValue, T>, IntValue> Get() const&& {
    return GetInt();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetList()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<ListValue, T>, ListValue> Get() & {
    return GetList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ListValue, T>, ListValue> Get() const& {
    return GetList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ListValue, T>, ListValue> Get() && {
    return std::move(*this).GetList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ListValue, T>, ListValue> Get() const&& {
    return std::move(*this).GetList();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetMap()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<MapValue, T>, MapValue> Get() & {
    return GetMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MapValue, T>, MapValue> Get() const& {
    return GetMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MapValue, T>, MapValue> Get() && {
    return std::move(*this).GetMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MapValue, T>, MapValue> Get() const&& {
    return std::move(*this).GetMap();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetMessage()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<MessageValue, T>, MessageValue> Get() & {
    return GetMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MessageValue, T>, MessageValue> Get() const& {
    return GetMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MessageValue, T>, MessageValue> Get() && {
    return std::move(*this).GetMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<MessageValue, T>, MessageValue> Get()
      const&& {
    return std::move(*this).GetMessage();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetNull()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<NullValue, T>, NullValue> Get() & {
    return GetNull();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<NullValue, T>, NullValue> Get() const& {
    return GetNull();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<NullValue, T>, NullValue> Get() && {
    return GetNull();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<NullValue, T>, NullValue> Get() const&& {
    return GetNull();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetOpaque()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<OpaqueValue, T>, const OpaqueValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetOpaque();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OpaqueValue, T>, const OpaqueValue&> Get()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetOpaque();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OpaqueValue, T>, OpaqueValue> Get() && {
    return std::move(*this).GetOpaque();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OpaqueValue, T>, OpaqueValue> Get() const&& {
    return std::move(*this).GetOpaque();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetOptional()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<OptionalValue, T>, const OptionalValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetOptional();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OptionalValue, T>, const OptionalValue&> Get()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetOptional();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OptionalValue, T>, OptionalValue> Get() && {
    return std::move(*this).GetOptional();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<OptionalValue, T>, OptionalValue> Get()
      const&& {
    return std::move(*this).GetOptional();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetParsedJsonList()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>,
                       const ParsedJsonListValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedJsonList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>,
                   const ParsedJsonListValue&>
  Get() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedJsonList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>, ParsedJsonListValue>
  Get() && {
    return std::move(*this).GetParsedJsonList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>, ParsedJsonListValue>
  Get() const&& {
    return std::move(*this).GetParsedJsonList();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetParsedJsonMap()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>,
                       const ParsedJsonMapValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedJsonMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>,
                   const ParsedJsonMapValue&>
  Get() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedJsonMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>, ParsedJsonMapValue>
  Get() && {
    return std::move(*this).GetParsedJsonMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>, ParsedJsonMapValue>
  Get() const&& {
    return std::move(*this).GetParsedJsonMap();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetCustomList()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<CustomListValue, T>,
                       const CustomListValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetCustomList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomListValue, T>, const CustomListValue&>
  Get() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetCustomList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomListValue, T>, CustomListValue>
  Get() && {
    return std::move(*this).GetCustomList();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomListValue, T>, CustomListValue> Get()
      const&& {
    return std::move(*this).GetCustomList();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetCustomMap()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<CustomMapValue, T>, const CustomMapValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetCustomMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomMapValue, T>, const CustomMapValue&>
  Get() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetCustomMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomMapValue, T>, CustomMapValue> Get() && {
    return std::move(*this).GetCustomMap();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomMapValue, T>, CustomMapValue> Get()
      const&& {
    return std::move(*this).GetCustomMap();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetParsedMapField()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>,
                       const ParsedMapFieldValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedMapField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>,
                   const ParsedMapFieldValue&>
  Get() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedMapField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>, ParsedMapFieldValue>
  Get() && {
    return std::move(*this).GetParsedMapField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>, ParsedMapFieldValue>
  Get() const&& {
    return std::move(*this).GetParsedMapField();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetParsedMessage()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedMessageValue, T>,
                       const ParsedMessageValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMessageValue, T>,
                   const ParsedMessageValue&>
  Get() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMessageValue, T>, ParsedMessageValue>
  Get() && {
    return std::move(*this).GetParsedMessage();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedMessageValue, T>, ParsedMessageValue>
  Get() const&& {
    return std::move(*this).GetParsedMessage();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetParsedRepeatedField()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>,
                       const ParsedRepeatedFieldValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedRepeatedField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>,
                   const ParsedRepeatedFieldValue&>
  Get() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetParsedRepeatedField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>,
                   ParsedRepeatedFieldValue>
  Get() && {
    return std::move(*this).GetParsedRepeatedField();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>,
                   ParsedRepeatedFieldValue>
  Get() const&& {
    return std::move(*this).GetParsedRepeatedField();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetCustomStruct()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<CustomStructValue, T>,
                       const CustomStructValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetCustomStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomStructValue, T>,
                   const CustomStructValue&>
  Get() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetCustomStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomStructValue, T>, CustomStructValue>
  Get() && {
    return std::move(*this).GetCustomStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<CustomStructValue, T>, CustomStructValue>
  Get() const&& {
    return std::move(*this).GetCustomStruct();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetString()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<StringValue, T>, const StringValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetString();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StringValue, T>, const StringValue&> Get()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetString();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StringValue, T>, StringValue> Get() && {
    return std::move(*this).GetString();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StringValue, T>, StringValue> Get() const&& {
    return std::move(*this).GetString();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetStruct()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<StructValue, T>, StructValue> Get() & {
    return GetStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StructValue, T>, StructValue> Get() const& {
    return GetStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StructValue, T>, StructValue> Get() && {
    return std::move(*this).GetStruct();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<StructValue, T>, StructValue> Get() const&& {
    return std::move(*this).GetStruct();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetTimestamp()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<TimestampValue, T>, TimestampValue> Get() & {
    return GetTimestamp();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TimestampValue, T>, TimestampValue> Get()
      const& {
    return GetTimestamp();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TimestampValue, T>, TimestampValue> Get() && {
    return GetTimestamp();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TimestampValue, T>, TimestampValue> Get()
      const&& {
    return GetTimestamp();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetType()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<TypeValue, T>, const TypeValue&> Get() &
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetType();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TypeValue, T>, const TypeValue&> Get()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetType();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TypeValue, T>, TypeValue> Get() && {
    return std::move(*this).GetType();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<TypeValue, T>, TypeValue> Get() const&& {
    return std::move(*this).GetType();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetUint()`.
  template <typename T>
  std::enable_if_t<std::is_same_v<UintValue, T>, UintValue> Get() & {
    return GetUint();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UintValue, T>, UintValue> Get() const& {
    return GetUint();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UintValue, T>, UintValue> Get() && {
    return GetUint();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UintValue, T>, UintValue> Get() const&& {
    return GetUint();
  }

  // Convenience method for use with template metaprogramming. See
  // `GetUnknown()`.
  template <typename T>
      std::enable_if_t<std::is_same_v<UnknownValue, T>, const UnknownValue&>
      Get() & ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetUnknown();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UnknownValue, T>, const UnknownValue&> Get()
      const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return GetUnknown();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UnknownValue, T>, UnknownValue> Get() && {
    return std::move(*this).GetUnknown();
  }
  template <typename T>
  std::enable_if_t<std::is_same_v<UnknownValue, T>, UnknownValue> Get()
      const&& {
    return std::move(*this).GetUnknown();
  }

  // When `Value` is default constructed, it is in a valid but undefined state.
  // Any attempt to use it invokes undefined behavior. This mention can be used
  // to test whether this value is valid.
  explicit operator bool() const { return true; }

 private:
  friend struct NativeTypeTraits<Value>;
  friend bool common_internal::IsLegacyListValue(const Value& value);
  friend common_internal::LegacyListValue common_internal::GetLegacyListValue(
      const Value& value);
  friend bool common_internal::IsLegacyMapValue(const Value& value);
  friend common_internal::LegacyMapValue common_internal::GetLegacyMapValue(
      const Value& value);
  friend bool common_internal::IsLegacyStructValue(const Value& value);
  friend common_internal::LegacyStructValue
  common_internal::GetLegacyStructValue(const Value& value);
  friend class common_internal::ValueMixin<Value>;
  friend struct ArenaTraits<Value>;

  common_internal::ValueVariant variant_;
};

// Overloads for heterogeneous equality of numeric values.
bool operator==(IntValue lhs, UintValue rhs);
bool operator==(UintValue lhs, IntValue rhs);
bool operator==(IntValue lhs, DoubleValue rhs);
bool operator==(DoubleValue lhs, IntValue rhs);
bool operator==(UintValue lhs, DoubleValue rhs);
bool operator==(DoubleValue lhs, UintValue rhs);
inline bool operator!=(IntValue lhs, UintValue rhs) {
  return !operator==(lhs, rhs);
}
inline bool operator!=(UintValue lhs, IntValue rhs) {
  return !operator==(lhs, rhs);
}
inline bool operator!=(IntValue lhs, DoubleValue rhs) {
  return !operator==(lhs, rhs);
}
inline bool operator!=(DoubleValue lhs, IntValue rhs) {
  return !operator==(lhs, rhs);
}
inline bool operator!=(UintValue lhs, DoubleValue rhs) {
  return !operator==(lhs, rhs);
}
inline bool operator!=(DoubleValue lhs, UintValue rhs) {
  return !operator==(lhs, rhs);
}

template <>
struct NativeTypeTraits<Value> final {
  static NativeTypeId Id(const Value& value) {
    return value.variant_.Visit([](const auto& alternative) -> NativeTypeId {
      return NativeTypeId::Of(alternative);
    });
  }
};

template <>
struct ArenaTraits<Value> {
  static bool trivially_destructible(const Value& value) {
    return value.variant_.Visit([](const auto& alternative) -> bool {
      return ArenaTraits<>::trivially_destructible(alternative);
    });
  }
};

// Statically assert some expectations.
static_assert(sizeof(Value) <= 32);
static_assert(alignof(Value) <= alignof(std::max_align_t));
static_assert(std::is_default_constructible_v<Value>);
static_assert(std::is_copy_constructible_v<Value>);
static_assert(std::is_copy_assignable_v<Value>);
static_assert(std::is_nothrow_move_constructible_v<Value>);
static_assert(std::is_nothrow_move_assignable_v<Value>);
static_assert(std::is_nothrow_swappable_v<Value>);

inline common_internal::ImplicitlyConvertibleStatus
ErrorValueAssign::operator()(absl::Status status) const {
  *value_ = ErrorValue::From(std::move(status), arena_);
  return common_internal::ImplicitlyConvertibleStatus();
}

namespace common_internal {

template <typename Base>
absl::StatusOr<Value> ValueMixin<Base>::Equal(
    const Value& other,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->Equal(
      other, descriptor_pool, message_factory, arena, &result));
  return result;
}

template <typename Base>
absl::StatusOr<Value> ListValueMixin<Base>::Get(
    size_t index, const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->Get(
      index, descriptor_pool, message_factory, arena, &result));
  return result;
}

template <typename Base>
absl::StatusOr<Value> ListValueMixin<Base>::Contains(
    const Value& other,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->Contains(
      other, descriptor_pool, message_factory, arena, &result));
  return result;
}

template <typename Base>
absl::StatusOr<Value> MapValueMixin<Base>::Get(
    const Value& key,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->Get(
      key, descriptor_pool, message_factory, arena, &result));
  return result;
}

template <typename Base>
absl::StatusOr<absl::optional<Value>> MapValueMixin<Base>::Find(
    const Value& other,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_ASSIGN_OR_RETURN(
      bool found, static_cast<const Base*>(this)->Find(
                      other, descriptor_pool, message_factory, arena, &result));
  if (found) {
    return result;
  }
  return absl::nullopt;
}

template <typename Base>
absl::StatusOr<Value> MapValueMixin<Base>::Has(
    const Value& key,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->Has(
      key, descriptor_pool, message_factory, arena, &result));
  return result;
}

template <typename Base>
absl::StatusOr<ListValue> MapValueMixin<Base>::ListKeys(
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  ListValue result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->ListKeys(
      descriptor_pool, message_factory, arena, &result));
  return result;
}

template <typename Base>
absl::StatusOr<Value> StructValueMixin<Base>::GetFieldByName(
    absl::string_view name,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->GetFieldByName(
      name, ProtoWrapperTypeOptions::kUnsetNull, descriptor_pool,
      message_factory, arena, &result));
  return result;
}

template <typename Base>
absl::StatusOr<Value> StructValueMixin<Base>::GetFieldByName(
    absl::string_view name, ProtoWrapperTypeOptions unboxing_options,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->GetFieldByName(
      name, unboxing_options, descriptor_pool, message_factory, arena,
      &result));
  return result;
}

template <typename Base>
absl::StatusOr<Value> StructValueMixin<Base>::GetFieldByNumber(
    int64_t number, const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->GetFieldByNumber(
      number, ProtoWrapperTypeOptions::kUnsetNull, descriptor_pool,
      message_factory, arena, &result));
  return result;
}

template <typename Base>
absl::StatusOr<Value> StructValueMixin<Base>::GetFieldByNumber(
    int64_t number, ProtoWrapperTypeOptions unboxing_options,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->GetFieldByNumber(
      number, unboxing_options, descriptor_pool, message_factory, arena,
      &result));
  return result;
}

template <typename Base>
absl::StatusOr<std::pair<Value, int>> StructValueMixin<Base>::Qualify(
    absl::Span<const SelectQualifier> qualifiers, bool presence_test,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) const {
  ABSL_DCHECK(!qualifiers.empty());
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  int count;
  CEL_RETURN_IF_ERROR(static_cast<const Base*>(this)->Qualify(
      qualifiers, presence_test, descriptor_pool, message_factory, arena,
      &result, &count));
  return std::pair{std::move(result), count};
}

}  // namespace common_internal

using ValueIteratorPtr = std::unique_ptr<ValueIterator>;

inline absl::StatusOr<Value> ValueIterator::Next(
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value result;
  CEL_RETURN_IF_ERROR(Next(descriptor_pool, message_factory, arena, &result));
  return result;
}

inline absl::StatusOr<absl::optional<Value>> ValueIterator::Next1(
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    google::protobuf::Arena* absl_nonnull arena) {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value key_or_value;
  CEL_ASSIGN_OR_RETURN(
      bool ok, Next1(descriptor_pool, message_factory, arena, &key_or_value));
  if (!ok) {
    return absl::nullopt;
  }
  return key_or_value;
}

inline absl::StatusOr<absl::optional<std::pair<Value, Value>>>
ValueIterator::Next2(const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
                     google::protobuf::MessageFactory* absl_nonnull message_factory,
                     google::protobuf::Arena* absl_nonnull arena) {
  ABSL_DCHECK(descriptor_pool != nullptr);
  ABSL_DCHECK(message_factory != nullptr);
  ABSL_DCHECK(arena != nullptr);

  Value key;
  Value value;
  CEL_ASSIGN_OR_RETURN(
      bool ok, Next2(descriptor_pool, message_factory, arena, &key, &value));
  if (!ok) {
    return absl::nullopt;
  }
  return std::pair{std::move(key), std::move(value)};
}

absl_nonnull std::unique_ptr<ValueIterator> NewEmptyValueIterator();

class ValueBuilder {
 public:
  virtual ~ValueBuilder() = default;

  virtual absl::StatusOr<absl::optional<ErrorValue>> SetFieldByName(
      absl::string_view name, Value value) = 0;

  virtual absl::StatusOr<absl::optional<ErrorValue>> SetFieldByNumber(
      int64_t number, Value value) = 0;

  virtual absl::StatusOr<Value> Build() && = 0;
};

using ValueBuilderPtr = std::unique_ptr<ValueBuilder>;

absl_nonnull ListValueBuilderPtr
NewListValueBuilder(google::protobuf::Arena* absl_nonnull arena);

absl_nonnull MapValueBuilderPtr
NewMapValueBuilder(google::protobuf::Arena* absl_nonnull arena);

// Returns a new `StructValueBuilder`. Returns `nullptr` if there is no such
// message type with the name `name` in `descriptor_pool`. Returns an error if
// `message_factory` is unable to provide a prototype for the descriptor
// returned from `descriptor_pool`.
absl_nullable StructValueBuilderPtr NewStructValueBuilder(
    google::protobuf::Arena* absl_nonnull arena,
    const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
    google::protobuf::MessageFactory* absl_nonnull message_factory,
    absl::string_view name);

using ListValueBuilderInterface = ListValueBuilder;
using MapValueBuilderInterface = MapValueBuilder;
using StructValueBuilderInterface = StructValueBuilder;

// Now that Value is complete, we can define various parts of list, map, opaque,
// and struct which depend on Value.

namespace common_internal {

using MapFieldKeyAccessor = void (*)(const google::protobuf::MapKey&,
                                     const google::protobuf::Message* absl_nonnull,
                                     google::protobuf::Arena* absl_nonnull,
                                     Value* absl_nonnull);

absl::StatusOr<MapFieldKeyAccessor> MapFieldKeyAccessorFor(
    const google::protobuf::FieldDescriptor* absl_nonnull field);

using MapFieldValueAccessor = void (*)(
    const google::protobuf::MapValueConstRef&, const google::protobuf::Message* absl_nonnull,
    const google::protobuf::FieldDescriptor* absl_nonnull,
    const google::protobuf::DescriptorPool* absl_nonnull,
    google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
    Value* absl_nonnull);

absl::StatusOr<MapFieldValueAccessor> MapFieldValueAccessorFor(
    const google::protobuf::FieldDescriptor* absl_nonnull field);

using RepeatedFieldAccessor =
    void (*)(int, const google::protobuf::Message* absl_nonnull,
             const google::protobuf::FieldDescriptor* absl_nonnull,
             const google::protobuf::Reflection* absl_nonnull,
             const google::protobuf::DescriptorPool* absl_nonnull,
             google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
             Value* absl_nonnull);

absl::StatusOr<RepeatedFieldAccessor> RepeatedFieldAccessorFor(
    const google::protobuf::FieldDescriptor* absl_nonnull field);

}  // namespace common_internal

inline BytesValue::BytesValue(const StringValue& other)
    : BytesValue(other.value_) {}

inline optional_ref<const BytesValue> Value::AsBytes() const& {
  if (const auto* alternative = variant_.As<BytesValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<BytesValue> Value::AsBytes() && {
  if (auto* alternative = variant_.As<BytesValue>(); alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline absl::optional<DoubleValue> Value::AsDouble() const {
  if (const auto* alternative = variant_.As<DoubleValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<DurationValue> Value::AsDuration() const {
  if (const auto* alternative = variant_.As<DurationValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline optional_ref<const ErrorValue> Value::AsError() const& {
  if (const auto* alternative = variant_.As<ErrorValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<ErrorValue> Value::AsError() && {
  if (auto* alternative = variant_.As<ErrorValue>(); alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline absl::optional<IntValue> Value::AsInt() const {
  if (const auto* alternative = variant_.As<IntValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<MessageValue> Value::AsMessage() const& {
  if (const auto* alternative = variant_.As<ParsedMessageValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<MessageValue> Value::AsMessage() && {
  if (auto* alternative = variant_.As<ParsedMessageValue>();
      alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline absl::optional<NullValue> Value::AsNull() const {
  if (const auto* alternative = variant_.As<NullValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline optional_ref<const OpaqueValue> Value::AsOpaque() const& {
  if (const auto* alternative = variant_.As<OpaqueValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<OpaqueValue> Value::AsOpaque() && {
  if (auto* alternative = variant_.As<OpaqueValue>(); alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const OptionalValue> Value::AsOptional() const& {
  if (const auto* alternative = variant_.As<OpaqueValue>();
      alternative != nullptr && alternative->IsOptional()) {
    return static_cast<const OptionalValue&>(*alternative);
  }
  return std::nullopt;
}

inline absl::optional<OptionalValue> Value::AsOptional() && {
  if (auto* alternative = variant_.As<OpaqueValue>();
      alternative != nullptr && alternative->IsOptional()) {
    return static_cast<OptionalValue&&>(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const ParsedJsonListValue> Value::AsParsedJsonList()
    const& {
  if (const auto* alternative = variant_.As<ParsedJsonListValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<ParsedJsonListValue> Value::AsParsedJsonList() && {
  if (auto* alternative = variant_.As<ParsedJsonListValue>();
      alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const ParsedJsonMapValue> Value::AsParsedJsonMap() const& {
  if (const auto* alternative = variant_.As<ParsedJsonMapValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<ParsedJsonMapValue> Value::AsParsedJsonMap() && {
  if (auto* alternative = variant_.As<ParsedJsonMapValue>();
      alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const CustomListValue> Value::AsCustomList() const& {
  if (const auto* alternative = variant_.As<CustomListValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<CustomListValue> Value::AsCustomList() && {
  if (auto* alternative = variant_.As<CustomListValue>();
      alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const CustomMapValue> Value::AsCustomMap() const& {
  if (const auto* alternative = variant_.As<CustomMapValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<CustomMapValue> Value::AsCustomMap() && {
  if (auto* alternative = variant_.As<CustomMapValue>();
      alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const ParsedMapFieldValue> Value::AsParsedMapField()
    const& {
  if (const auto* alternative = variant_.As<ParsedMapFieldValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<ParsedMapFieldValue> Value::AsParsedMapField() && {
  if (auto* alternative = variant_.As<ParsedMapFieldValue>();
      alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const ParsedMessageValue> Value::AsParsedMessage() const& {
  if (const auto* alternative = variant_.As<ParsedMessageValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<ParsedMessageValue> Value::AsParsedMessage() && {
  if (auto* alternative = variant_.As<ParsedMessageValue>();
      alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const ParsedRepeatedFieldValue>
Value::AsParsedRepeatedField() const& {
  if (const auto* alternative = variant_.As<ParsedRepeatedFieldValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<ParsedRepeatedFieldValue>
Value::AsParsedRepeatedField() && {
  if (auto* alternative = variant_.As<ParsedRepeatedFieldValue>();
      alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const CustomStructValue> Value::AsCustomStruct() const& {
  if (const auto* alternative = variant_.As<CustomStructValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<CustomStructValue> Value::AsCustomStruct() && {
  if (auto* alternative = variant_.As<CustomStructValue>();
      alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline optional_ref<const StringValue> Value::AsString() const& {
  if (const auto* alternative = variant_.As<StringValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<StringValue> Value::AsString() && {
  if (auto* alternative = variant_.As<StringValue>(); alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline absl::optional<TimestampValue> Value::AsTimestamp() const {
  if (const auto* alternative = variant_.As<TimestampValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline optional_ref<const TypeValue> Value::AsType() const& {
  if (const auto* alternative = variant_.As<TypeValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<TypeValue> Value::AsType() && {
  if (auto* alternative = variant_.As<TypeValue>(); alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline absl::optional<UintValue> Value::AsUint() const {
  if (const auto* alternative = variant_.As<UintValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline optional_ref<const UnknownValue> Value::AsUnknown() const& {
  if (const auto* alternative = variant_.As<UnknownValue>();
      alternative != nullptr) {
    return *alternative;
  }
  return std::nullopt;
}

inline absl::optional<UnknownValue> Value::AsUnknown() && {
  if (auto* alternative = variant_.As<UnknownValue>(); alternative != nullptr) {
    return std::move(*alternative);
  }
  return std::nullopt;
}

inline const BytesValue& Value::GetBytes() const& {
  ABSL_DCHECK(IsBytes()) << *this;
  return variant_.Get<BytesValue>();
}

inline BytesValue Value::GetBytes() && {
  ABSL_DCHECK(IsBytes()) << *this;
  return std::move(variant_).Get<BytesValue>();
}

inline DoubleValue Value::GetDouble() const {
  ABSL_DCHECK(IsDouble()) << *this;
  return variant_.Get<DoubleValue>();
}

inline DurationValue Value::GetDuration() const {
  ABSL_DCHECK(IsDuration()) << *this;
  return variant_.Get<DurationValue>();
}

inline const ErrorValue& Value::GetError() const& {
  ABSL_DCHECK(IsError()) << *this;
  return variant_.Get<ErrorValue>();
}

inline ErrorValue Value::GetError() && {
  ABSL_DCHECK(IsError()) << *this;
  return std::move(variant_).Get<ErrorValue>();
}

inline IntValue Value::GetInt() const {
  ABSL_DCHECK(IsInt()) << *this;
  return variant_.Get<IntValue>();
}

inline MessageValue Value::GetMessage() const& {
  ABSL_DCHECK(IsMessage()) << *this;
  return variant_.Get<ParsedMessageValue>();
}

inline MessageValue Value::GetMessage() && {
  ABSL_DCHECK(IsMessage()) << *this;
  return std::move(variant_).Get<ParsedMessageValue>();
}

inline NullValue Value::GetNull() const {
  ABSL_DCHECK(IsNull()) << *this;
  return variant_.Get<NullValue>();
}

inline const OpaqueValue& Value::GetOpaque() const& {
  ABSL_DCHECK(IsOpaque()) << *this;
  return variant_.Get<OpaqueValue>();
}

inline OpaqueValue Value::GetOpaque() && {
  ABSL_DCHECK(IsOpaque()) << *this;
  return std::move(variant_).Get<OpaqueValue>();
}

inline const OptionalValue& Value::GetOptional() const& {
  ABSL_DCHECK(IsOptional()) << *this;
  return static_cast<const OptionalValue&>(variant_.Get<OpaqueValue>());
}

inline OptionalValue Value::GetOptional() && {
  ABSL_DCHECK(IsOptional()) << *this;
  return static_cast<OptionalValue&&>(std::move(variant_).Get<OpaqueValue>());
}

inline const ParsedJsonListValue& Value::GetParsedJsonList() const& {
  ABSL_DCHECK(IsParsedJsonList()) << *this;
  return variant_.Get<ParsedJsonListValue>();
}

inline ParsedJsonListValue Value::GetParsedJsonList() && {
  ABSL_DCHECK(IsParsedJsonList()) << *this;
  return std::move(variant_).Get<ParsedJsonListValue>();
}

inline const ParsedJsonMapValue& Value::GetParsedJsonMap() const& {
  ABSL_DCHECK(IsParsedJsonMap()) << *this;
  return variant_.Get<ParsedJsonMapValue>();
}

inline ParsedJsonMapValue Value::GetParsedJsonMap() && {
  ABSL_DCHECK(IsParsedJsonMap()) << *this;
  return std::move(variant_).Get<ParsedJsonMapValue>();
}

inline const CustomListValue& Value::GetCustomList() const& {
  ABSL_DCHECK(IsCustomList()) << *this;
  return variant_.Get<CustomListValue>();
}

inline CustomListValue Value::GetCustomList() && {
  ABSL_DCHECK(IsCustomList()) << *this;
  return std::move(variant_).Get<CustomListValue>();
}

inline const CustomMapValue& Value::GetCustomMap() const& {
  ABSL_DCHECK(IsCustomMap()) << *this;
  return variant_.Get<CustomMapValue>();
}

inline CustomMapValue Value::GetCustomMap() && {
  ABSL_DCHECK(IsCustomMap()) << *this;
  return std::move(variant_).Get<CustomMapValue>();
}

inline const ParsedMapFieldValue& Value::GetParsedMapField() const& {
  ABSL_DCHECK(IsParsedMapField()) << *this;
  return variant_.Get<ParsedMapFieldValue>();
}

inline ParsedMapFieldValue Value::GetParsedMapField() && {
  ABSL_DCHECK(IsParsedMapField()) << *this;
  return std::move(variant_).Get<ParsedMapFieldValue>();
}

inline const ParsedMessageValue& Value::GetParsedMessage() const& {
  ABSL_DCHECK(IsParsedMessage()) << *this;
  return variant_.Get<ParsedMessageValue>();
}

inline ParsedMessageValue Value::GetParsedMessage() && {
  ABSL_DCHECK(IsParsedMessage()) << *this;
  return std::move(variant_).Get<ParsedMessageValue>();
}

inline const ParsedRepeatedFieldValue& Value::GetParsedRepeatedField() const& {
  ABSL_DCHECK(IsParsedRepeatedField()) << *this;
  return variant_.Get<ParsedRepeatedFieldValue>();
}

inline ParsedRepeatedFieldValue Value::GetParsedRepeatedField() && {
  ABSL_DCHECK(IsParsedRepeatedField()) << *this;
  return std::move(variant_).Get<ParsedRepeatedFieldValue>();
}

inline const CustomStructValue& Value::GetCustomStruct() const& {
  ABSL_DCHECK(IsCustomStruct()) << *this;
  return variant_.Get<CustomStructValue>();
}

inline CustomStructValue Value::GetCustomStruct() && {
  ABSL_DCHECK(IsCustomStruct()) << *this;
  return std::move(variant_).Get<CustomStructValue>();
}

inline const StringValue& Value::GetString() const& {
  ABSL_DCHECK(IsString()) << *this;
  return variant_.Get<StringValue>();
}

inline StringValue Value::GetString() && {
  ABSL_DCHECK(IsString()) << *this;
  return std::move(variant_).Get<StringValue>();
}

inline TimestampValue Value::GetTimestamp() const {
  ABSL_DCHECK(IsTimestamp()) << *this;
  return variant_.Get<TimestampValue>();
}

inline const TypeValue& Value::GetType() const& {
  ABSL_DCHECK(IsType()) << *this;
  return variant_.Get<TypeValue>();
}

inline TypeValue Value::GetType() && {
  ABSL_DCHECK(IsType()) << *this;
  return std::move(variant_).Get<TypeValue>();
}

inline UintValue Value::GetUint() const {
  ABSL_DCHECK(IsUint()) << *this;
  return variant_.Get<UintValue>();
}

inline const UnknownValue& Value::GetUnknown() const& {
  ABSL_DCHECK(IsUnknown()) << *this;
  return variant_.Get<UnknownValue>();
}

inline UnknownValue Value::GetUnknown() && {
  ABSL_DCHECK(IsUnknown()) << *this;
  return std::move(variant_).Get<UnknownValue>();
}

}  // namespace cel

#pragma pop_macro("GetMessage")

#endif  // THIRD_PARTY_CEL_CPP_COMMON_VALUE_H_

Coverage Report

Created: 2026-10-09 06:57