diff --git a/common/BUILD b/common/BUILD
index ab1d389a8..b2c1d1f84 100644
--- a/common/BUILD
+++ b/common/BUILD
@@ -830,6 +830,7 @@ cc_library(
         "@com_google_absl//absl/strings:string_view",
         "@com_google_absl//absl/time",
         "@com_google_absl//absl/types:optional",
+        "@com_google_absl//absl/types:optional_ref",
         "@com_google_absl//absl/types:source_location",
         "@com_google_absl//absl/types:span",
         "@com_google_absl//absl/types:variant",
@@ -976,9 +977,7 @@ cc_library(
     hdrs = ["optional_ref.h"],
     deps = [
         "@com_google_absl//absl/base:core_headers",
-        "@com_google_absl//absl/base:nullability",
-        "@com_google_absl//absl/types:optional",
-        "@com_google_absl//absl/utility",
+        "@com_google_absl//absl/types:optional_ref",
     ],
 )
 
diff --git a/common/optional_ref.h b/common/optional_ref.h
index c7ba580fc..bc715b8f8 100644
--- a/common/optional_ref.h
+++ b/common/optional_ref.h
@@ -15,15 +15,11 @@
 #ifndef THIRD_PARTY_CEL_CPP_OPTIONAL_REF_H_
 #define THIRD_PARTY_CEL_CPP_OPTIONAL_REF_H_
 
-#include <memory>
+#include <optional>
 #include <type_traits>
 
-#include "absl/base/attributes.h"
 #include "absl/base/macros.h"
-#include "absl/base/nullability.h"
-#include "absl/base/optimization.h"
-#include "absl/types/optional.h"
-#include "absl/utility/utility.h"
+#include "absl/types/optional_ref.h"
 
 namespace cel {
 
@@ -31,128 +27,22 @@ namespace cel {
 // owning the underlying value, it retains a reference to the value it accepts
 // in its constructor.
 template <typename T>
-class optional_ref final {
- public:
-  static_assert(!std::is_reference_v<T>, "T must not be a reference.");
-  static_assert(!std::is_same_v<absl::nullopt_t, std::remove_cv_t<T>>,
-                "optional_ref<absl::nullopt_t> is not allowed.");
-  static_assert(!std::is_same_v<absl::in_place_t, std::remove_cv_t<T>>,
-                "optional_ref<absl::in_place_t> is not allowed.");
-
-  using value_type = T;
-
-  optional_ref() = default;
-
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(absl::nullopt_t) : optional_ref() {}
-
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(T& value ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : value_(std::addressof(value)) {}
-
-  template <
-      typename U,
-      typename = std::enable_if_t<std::conjunction_v<
-          std::is_const<T>, std::is_same<std::decay_t<U>, std::decay_t<T>>>>>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(
-      const absl::optional<U>& value ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : value_(value.has_value() ? std::addressof(*value) : nullptr) {}
-
-  template <typename U, typename = std::enable_if_t<
-                            std::is_same_v<std::decay_t<U>, std::decay_t<T>>>>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(absl::optional<U>& value ABSL_ATTRIBUTE_LIFETIME_BOUND)
-      : value_(value.has_value() ? std::addressof(*value) : nullptr) {}
-
-  template <
-      typename U,
-      typename = std::enable_if_t<std::conjunction_v<
-          std::negation<std::is_same<U, T>>,
-          std::is_convertible<std::add_pointer_t<U>, std::add_pointer_t<T>>>>>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr optional_ref(const optional_ref<U>& other) : value_(other.value_) {}
-
-  optional_ref(const optional_ref<T>&) = default;
-
-  optional_ref<T>& operator=(const optional_ref<T>&) = delete;
-
-  constexpr bool has_value() const { return value_ != nullptr; }
-
-  constexpr explicit operator bool() const { return has_value(); }
-
-  constexpr T& value() const {
-    return ABSL_PREDICT_TRUE(has_value())
-               ? *value_
-               // Replicate the same error logic as in `absl::optional`'s
-               // `value()`. It either throws an exception or aborts the
-               // program. We intentionally ignore the return value of
-               // the constructed optional's value as we only need to run
-               // the code for error checking.
-               : ((void)absl::optional<T>().value(), *value_);
-  }
-
-  constexpr T& operator*() const {
-    ABSL_ASSERT(has_value());
-    return *value_;
-  }
-
-  constexpr T* absl_nonnull operator->() const {
-    ABSL_ASSERT(has_value());
-    return value_;
-  }
-
- private:
-  template <typename U>
-  friend class optional_ref;
-
-  T* const value_ = nullptr;
-};
-
-template <typename T>
-optional_ref(const T&) -> optional_ref<const T>;
-
-template <typename T>
-optional_ref(T&) -> optional_ref<T>;
-
-template <typename T>
-optional_ref(const absl::optional<T>&) -> optional_ref<const T>;
-
-template <typename T>
-optional_ref(absl::optional<T>&) -> optional_ref<T>;
-
-template <typename T>
-constexpr bool operator==(const optional_ref<T>& lhs, absl::nullopt_t) {
-  return !lhs.has_value();
-}
-
-template <typename T>
-constexpr bool operator==(absl::nullopt_t, const optional_ref<T>& rhs) {
-  return !rhs.has_value();
-}
-
-template <typename T>
-constexpr bool operator!=(const optional_ref<T>& lhs, absl::nullopt_t) {
-  return !operator==(lhs, absl::nullopt);
-}
-
-template <typename T>
-constexpr bool operator!=(absl::nullopt_t, const optional_ref<T>& rhs) {
-  return !operator==(absl::nullopt, rhs);
-}
+using optional_ref ABSL_DEPRECATE_AND_INLINE() = absl::optional_ref<T>;
 
 namespace common_internal {
 
 template <typename T>
-absl::optional<std::decay_t<T>> AsOptional(optional_ref<T> ref) {
-  if (ref) {
+[[nodiscard]]
+std::optional<std::decay_t<T>> AsOptional(absl::optional_ref<T> ref) {
+  if (ref.has_value()) {
     return *ref;
   }
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 template <typename T>
-absl::optional<T> AsOptional(absl::optional<T> opt) {
+[[nodiscard]]
+std::optional<T> AsOptional(std::optional<T> opt) {
   return opt;
 }
 
diff --git a/common/value.cc b/common/value.cc
index 1656d4857..98c589b2a 100644
--- a/common/value.cc
+++ b/common/value.cc
@@ -40,11 +40,11 @@
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
 #include "absl/types/optional.h"
+#include "absl/types/optional_ref.h"
 #include "absl/types/source_location.h"
 #include "absl/types/variant.h"
 #include "common/allocator.h"
 #include "common/memory.h"
-#include "common/optional_ref.h"
 #include "common/type.h"
 #include "common/value_kind.h"
 #include "common/values/list_value_builder.h"
@@ -2008,7 +2008,7 @@ Value Value::WrapMapFieldValueUnsafe(
                                        message_factory, arena);
 }
 
-optional_ref<const BytesValue> Value::AsBytes() const& {
+absl::optional_ref<const BytesValue> Value::AsBytes() const& {
   if (const auto* alternative = variant_.As<BytesValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2039,7 +2039,7 @@ absl::optional<DurationValue> Value::AsDuration() const {
   return std::nullopt;
 }
 
-optional_ref<const ErrorValue> Value::AsError() const& {
+absl::optional_ref<const ErrorValue> Value::AsError() const& {
   if (const auto* alternative = variant_.As<ErrorValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2166,7 +2166,7 @@ absl::optional<NullValue> Value::AsNull() const {
   return std::nullopt;
 }
 
-optional_ref<const OpaqueValue> Value::AsOpaque() const& {
+absl::optional_ref<const OpaqueValue> Value::AsOpaque() const& {
   if (const auto* alternative = variant_.As<OpaqueValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2181,7 +2181,7 @@ absl::optional<OpaqueValue> Value::AsOpaque() && {
   return std::nullopt;
 }
 
-optional_ref<const OptionalValue> Value::AsOptional() const& {
+absl::optional_ref<const OptionalValue> Value::AsOptional() const& {
   if (const auto* alternative = variant_.As<OpaqueValue>();
       alternative != nullptr && alternative->IsOptional()) {
     return static_cast<const OptionalValue&>(*alternative);
@@ -2197,7 +2197,7 @@ absl::optional<OptionalValue> Value::AsOptional() && {
   return std::nullopt;
 }
 
-optional_ref<const ParsedJsonListValue> Value::AsParsedJsonList() const& {
+absl::optional_ref<const ParsedJsonListValue> Value::AsParsedJsonList() const& {
   if (const auto* alternative = variant_.As<ParsedJsonListValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2213,7 +2213,7 @@ absl::optional<ParsedJsonListValue> Value::AsParsedJsonList() && {
   return std::nullopt;
 }
 
-optional_ref<const ParsedJsonMapValue> Value::AsParsedJsonMap() const& {
+absl::optional_ref<const ParsedJsonMapValue> Value::AsParsedJsonMap() const& {
   if (const auto* alternative = variant_.As<ParsedJsonMapValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2229,7 +2229,7 @@ absl::optional<ParsedJsonMapValue> Value::AsParsedJsonMap() && {
   return std::nullopt;
 }
 
-optional_ref<const CustomListValue> Value::AsCustomList() const& {
+absl::optional_ref<const CustomListValue> Value::AsCustomList() const& {
   if (const auto* alternative = variant_.As<CustomListValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2245,7 +2245,7 @@ absl::optional<CustomListValue> Value::AsCustomList() && {
   return std::nullopt;
 }
 
-optional_ref<const CustomMapValue> Value::AsCustomMap() const& {
+absl::optional_ref<const CustomMapValue> Value::AsCustomMap() const& {
   if (const auto* alternative = variant_.As<CustomMapValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2261,7 +2261,7 @@ absl::optional<CustomMapValue> Value::AsCustomMap() && {
   return std::nullopt;
 }
 
-optional_ref<const ParsedMapFieldValue> Value::AsParsedMapField() const& {
+absl::optional_ref<const ParsedMapFieldValue> Value::AsParsedMapField() const& {
   if (const auto* alternative = variant_.As<ParsedMapFieldValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2277,7 +2277,7 @@ absl::optional<ParsedMapFieldValue> Value::AsParsedMapField() && {
   return std::nullopt;
 }
 
-optional_ref<const ParsedMessageValue> Value::AsParsedMessage() const& {
+absl::optional_ref<const ParsedMessageValue> Value::AsParsedMessage() const& {
   if (const auto* alternative = variant_.As<ParsedMessageValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2293,8 +2293,8 @@ absl::optional<ParsedMessageValue> Value::AsParsedMessage() && {
   return std::nullopt;
 }
 
-optional_ref<const ParsedRepeatedFieldValue> Value::AsParsedRepeatedField()
-    const& {
+absl::optional_ref<const ParsedRepeatedFieldValue>
+Value::AsParsedRepeatedField() const& {
   if (const auto* alternative = variant_.As<ParsedRepeatedFieldValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2310,7 +2310,7 @@ absl::optional<ParsedRepeatedFieldValue> Value::AsParsedRepeatedField() && {
   return std::nullopt;
 }
 
-optional_ref<const CustomStructValue> Value::AsCustomStruct() const& {
+absl::optional_ref<const CustomStructValue> Value::AsCustomStruct() const& {
   if (const auto* alternative = variant_.As<CustomStructValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2326,7 +2326,7 @@ absl::optional<CustomStructValue> Value::AsCustomStruct() && {
   return std::nullopt;
 }
 
-optional_ref<const StringValue> Value::AsString() const& {
+absl::optional_ref<const StringValue> Value::AsString() const& {
   if (const auto* alternative = variant_.As<StringValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2382,7 +2382,7 @@ absl::optional<TimestampValue> Value::AsTimestamp() const {
   return std::nullopt;
 }
 
-optional_ref<const TypeValue> Value::AsType() const& {
+absl::optional_ref<const TypeValue> Value::AsType() const& {
   if (const auto* alternative = variant_.As<TypeValue>();
       alternative != nullptr) {
     return *alternative;
@@ -2405,7 +2405,7 @@ absl::optional<UintValue> Value::AsUint() const {
   return std::nullopt;
 }
 
-optional_ref<const UnknownValue> Value::AsUnknown() const& {
+absl::optional_ref<const UnknownValue> Value::AsUnknown() const& {
   if (const auto* alternative = variant_.As<UnknownValue>();
       alternative != nullptr) {
     return *alternative;
diff --git a/common/value.h b/common/value.h
index 881f8c925..734d13c84 100644
--- a/common/value.h
+++ b/common/value.h
@@ -32,6 +32,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "absl/types/optional_ref.h"
 #include "absl/types/span.h"
 #include "absl/utility/utility.h"
 #include "base/attribute.h"
@@ -806,10 +807,12 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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 {
+  absl::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_ref<const BytesValue> AsBytes()
+      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<BytesValue> AsBytes() &&;
   absl::optional<BytesValue> AsBytes() const&& {
     return common_internal::AsOptional(AsBytes());
@@ -828,10 +831,12 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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 {
+  absl::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_ref<const ErrorValue> AsError()
+      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<ErrorValue> AsError() &&;
   absl::optional<ErrorValue> AsError() const&& {
     return common_internal::AsOptional(AsError());
@@ -882,10 +887,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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 {
+  absl::optional_ref<const OpaqueValue> AsOpaque() &
+      ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsOpaque();
   }
-  optional_ref<const OpaqueValue> AsOpaque()
+  absl::optional_ref<const OpaqueValue> AsOpaque()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<OpaqueValue> AsOpaque() &&;
   absl::optional<OpaqueValue> AsOpaque() const&& {
@@ -895,11 +901,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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::optional_ref<const OptionalValue> AsOptional() &
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsOptional();
   }
-  optional_ref<const OptionalValue> AsOptional()
+  absl::optional_ref<const OptionalValue> AsOptional()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<OptionalValue> AsOptional() &&;
   absl::optional<OptionalValue> AsOptional() const&& {
@@ -909,11 +915,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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::optional_ref<const ParsedJsonListValue> AsParsedJsonList() &
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsParsedJsonList();
   }
-  optional_ref<const ParsedJsonListValue> AsParsedJsonList()
+  absl::optional_ref<const ParsedJsonListValue> AsParsedJsonList()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<ParsedJsonListValue> AsParsedJsonList() &&;
   absl::optional<ParsedJsonListValue> AsParsedJsonList() const&& {
@@ -923,11 +929,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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::optional_ref<const ParsedJsonMapValue> AsParsedJsonMap() &
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsParsedJsonMap();
   }
-  optional_ref<const ParsedJsonMapValue> AsParsedJsonMap()
+  absl::optional_ref<const ParsedJsonMapValue> AsParsedJsonMap()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<ParsedJsonMapValue> AsParsedJsonMap() &&;
   absl::optional<ParsedJsonMapValue> AsParsedJsonMap() const&& {
@@ -937,11 +943,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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::optional_ref<const CustomListValue> AsCustomList() &
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsCustomList();
   }
-  optional_ref<const CustomListValue> AsCustomList()
+  absl::optional_ref<const CustomListValue> AsCustomList()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<CustomListValue> AsCustomList() &&;
   absl::optional<CustomListValue> AsCustomList() const&& {
@@ -951,11 +957,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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::optional_ref<const CustomMapValue> AsCustomMap() &
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsCustomMap();
   }
-  optional_ref<const CustomMapValue> AsCustomMap()
+  absl::optional_ref<const CustomMapValue> AsCustomMap()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<CustomMapValue> AsCustomMap() &&;
   absl::optional<CustomMapValue> AsCustomMap() const&& {
@@ -965,11 +971,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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::optional_ref<const ParsedMapFieldValue> AsParsedMapField() &
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsParsedMapField();
   }
-  optional_ref<const ParsedMapFieldValue> AsParsedMapField()
+  absl::optional_ref<const ParsedMapFieldValue> AsParsedMapField()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<ParsedMapFieldValue> AsParsedMapField() &&;
   absl::optional<ParsedMapFieldValue> AsParsedMapField() const&& {
@@ -979,11 +985,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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::optional_ref<const ParsedMessageValue> AsParsedMessage() &
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsParsedMessage();
   }
-  optional_ref<const ParsedMessageValue> AsParsedMessage()
+  absl::optional_ref<const ParsedMessageValue> AsParsedMessage()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<ParsedMessageValue> AsParsedMessage() &&;
   absl::optional<ParsedMessageValue> AsParsedMessage() const&& {
@@ -993,11 +999,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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::optional_ref<const ParsedRepeatedFieldValue> AsParsedRepeatedField() &
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsParsedRepeatedField();
   }
-  optional_ref<const ParsedRepeatedFieldValue> AsParsedRepeatedField()
+  absl::optional_ref<const ParsedRepeatedFieldValue> AsParsedRepeatedField()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<ParsedRepeatedFieldValue> AsParsedRepeatedField() &&;
   absl::optional<ParsedRepeatedFieldValue> AsParsedRepeatedField() const&& {
@@ -1007,11 +1013,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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::optional_ref<const CustomStructValue> AsCustomStruct() &
       ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsCustomStruct();
   }
-  optional_ref<const CustomStructValue> AsCustomStruct()
+  absl::optional_ref<const CustomStructValue> AsCustomStruct()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<CustomStructValue> AsCustomStruct() &&;
   absl::optional<CustomStructValue> AsCustomStruct() const&& {
@@ -1021,10 +1027,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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 {
+  absl::optional_ref<const StringValue> AsString() &
+      ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsString();
   }
-  optional_ref<const StringValue> AsString()
+  absl::optional_ref<const StringValue> AsString()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<StringValue> AsString() &&;
   absl::optional<StringValue> AsString() const&& {
@@ -1051,10 +1058,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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 {
+  absl::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_ref<const TypeValue> AsType()
+      const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<TypeValue> AsType() &&;
   absl::optional<TypeValue> AsType() const&& {
     return common_internal::AsOptional(AsType());
@@ -1068,10 +1076,11 @@ class Value final : private common_internal::ValueMixin<Value> {
   // 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 {
+  absl::optional_ref<const UnknownValue> AsUnknown() &
+      ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return std::as_const(*this).AsUnknown();
   }
-  optional_ref<const UnknownValue> AsUnknown()
+  absl::optional_ref<const UnknownValue> AsUnknown()
       const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   absl::optional<UnknownValue> AsUnknown() &&;
   absl::optional<UnknownValue> AsUnknown() const&& {
@@ -1105,13 +1114,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsBytes()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<BytesValue, T>,
-                       optional_ref<const BytesValue>>
+                       absl::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>>
+                   absl::optional_ref<const BytesValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsBytes();
   }
@@ -1180,13 +1189,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsError()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<ErrorValue, T>,
-                       optional_ref<const ErrorValue>>
+                       absl::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>>
+                   absl::optional_ref<const ErrorValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsError();
   }
@@ -1324,13 +1333,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsOpaque()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<OpaqueValue, T>,
-                       optional_ref<const OpaqueValue>>
+                       absl::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>>
+                   absl::optional_ref<const OpaqueValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsOpaque();
   }
@@ -1349,13 +1358,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsOptional()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<OptionalValue, T>,
-                       optional_ref<const OptionalValue>>
+                       absl::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>>
+                   absl::optional_ref<const OptionalValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsOptional();
   }
@@ -1376,13 +1385,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsParsedJsonList()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<ParsedJsonListValue, T>,
-                       optional_ref<const ParsedJsonListValue>>
+                       absl::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>>
+                   absl::optional_ref<const ParsedJsonListValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsParsedJsonList();
   }
@@ -1403,13 +1412,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsParsedJsonMap()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<ParsedJsonMapValue, T>,
-                       optional_ref<const ParsedJsonMapValue>>
+                       absl::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>>
+                   absl::optional_ref<const ParsedJsonMapValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsParsedJsonMap();
   }
@@ -1430,13 +1439,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsCustomList()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<CustomListValue, T>,
-                       optional_ref<const CustomListValue>>
+                       absl::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>>
+                   absl::optional_ref<const CustomListValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsCustomList();
   }
@@ -1457,13 +1466,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsCustomMap()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<CustomMapValue, T>,
-                       optional_ref<const CustomMapValue>>
+                       absl::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>>
+                   absl::optional_ref<const CustomMapValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsCustomMap();
   }
@@ -1484,13 +1493,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsParsedMapField()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<ParsedMapFieldValue, T>,
-                       optional_ref<const ParsedMapFieldValue>>
+                       absl::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>>
+                   absl::optional_ref<const ParsedMapFieldValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsParsedMapField();
   }
@@ -1511,13 +1520,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsParsedMessage()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<ParsedMessageValue, T>,
-                       optional_ref<const ParsedMessageValue>>
+                       absl::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>>
+                   absl::optional_ref<const ParsedMessageValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsParsedMessage();
   }
@@ -1538,13 +1547,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsParsedRepeatedField()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<ParsedRepeatedFieldValue, T>,
-                       optional_ref<const ParsedRepeatedFieldValue>>
+                       absl::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>>
+                   absl::optional_ref<const ParsedRepeatedFieldValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsParsedRepeatedField();
   }
@@ -1565,13 +1574,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsCustomStruct()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<CustomStructValue, T>,
-                       optional_ref<const CustomStructValue>>
+                       absl::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>>
+                   absl::optional_ref<const CustomStructValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsCustomStruct();
   }
@@ -1592,13 +1601,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsString()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<StringValue, T>,
-                       optional_ref<const StringValue>>
+                       absl::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>>
+                   absl::optional_ref<const StringValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsString();
   }
@@ -1667,12 +1676,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsType()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<TypeValue, T>,
-                       optional_ref<const TypeValue>>
+                       absl::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>>
+  std::enable_if_t<std::is_same_v<TypeValue, T>,
+                   absl::optional_ref<const TypeValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsType();
   }
@@ -1714,13 +1724,13 @@ class Value final : private common_internal::ValueMixin<Value> {
   // `AsUnknown()`.
   template <typename T>
       std::enable_if_t<std::is_same_v<UnknownValue, T>,
-                       optional_ref<const UnknownValue>>
+                       absl::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>>
+                   absl::optional_ref<const UnknownValue>>
   As() const& ABSL_ATTRIBUTE_LIFETIME_BOUND {
     return AsUnknown();
   }