diff --git a/common/internal/BUILD b/common/internal/BUILD
index 10084b685..8803c5487 100644
--- a/common/internal/BUILD
+++ b/common/internal/BUILD
@@ -143,6 +143,7 @@ cc_library(
     srcs = ["signature.cc"],
     hdrs = ["signature.h"],
     deps = [
+        "//common:ast",
         "//common:type",
         "//common:type_kind",
         "//internal:status_macros",
@@ -150,7 +151,7 @@ cc_library(
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",
-        "@com_google_absl//absl/strings:string_view",
+        "@com_google_protobuf//:protobuf",
     ],
 )
 
@@ -159,11 +160,14 @@ cc_test(
     srcs = ["signature_test.cc"],
     deps = [
         ":signature",
+        "//common:ast",
         "//common:type",
+        "//common:type_kind",
         "//internal:testing",
         "//internal:testing_descriptor_pool",
         "@com_google_absl//absl/base:no_destructor",
         "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:status_matchers",
         "@com_google_absl//absl/status:statusor",
         "@com_google_protobuf//:protobuf",
     ],
diff --git a/common/internal/signature.cc b/common/internal/signature.cc
index f63049878..98fd0e017 100644
--- a/common/internal/signature.cc
+++ b/common/internal/signature.cc
@@ -15,17 +15,24 @@
 #include "common/internal/signature.h"
 
 #include <cstddef>
+#include <cstring>
+#include <memory>
 #include <string>
 #include <string_view>
+#include <utility>
 #include <vector>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "common/ast.h"
 #include "common/type.h"
 #include "common/type_kind.h"
 #include "internal/status_macros.h"
+#include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
 
 namespace cel::common_internal {
 
@@ -208,4 +215,419 @@ absl::StatusOr<std::string> MakeOverloadSignature(
 
   return result;
 }
+
+namespace {
+
+std::string Unescape(std::string_view str) {
+  std::string result;
+  bool escaped = false;
+  for (char c : str) {
+    if (escaped) {
+      result.push_back(c);
+      escaped = false;
+    } else if (c == '\\') {
+      escaped = true;
+    } else {
+      result.push_back(c);
+    }
+  }
+  if (escaped) {
+    result.push_back('\\');
+  }
+  return result;
+}
+
+absl::StatusOr<std::vector<std::string_view>> SplitTypeList(
+    std::string_view params) {
+  std::vector<std::string_view> result;
+  int nesting = 0;
+  bool escaped = false;
+  size_t start = 0;
+  for (size_t i = 0; i < params.size(); ++i) {
+    char c = params[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (c == '\\') {
+      escaped = true;
+    } else if (c == '<') {
+      nesting++;
+    } else if (c == '>') {
+      nesting--;
+      if (nesting < 0) {
+        return absl::InvalidArgumentError(
+            "Invalid type signature: extra closing >");
+      }
+    } else if (c == ',' && nesting == 0) {
+      result.push_back(params.substr(start, i - start));
+      start = i + 1;
+    }
+  }
+  if (nesting != 0) {
+    return absl::InvalidArgumentError(
+        "Invalid type signature: mismatched brackets");
+  }
+  if (start < params.size()) {
+    result.push_back(params.substr(start));
+  }
+  return result;
+}
+
+}  // namespace
+
+absl::StatusOr<TypeSpec> ParseTypeSignature(std::string_view signature) {
+  if (signature.empty()) {
+    return absl::InvalidArgumentError("Empty type signature");
+  }
+
+  if (signature[0] == '~') {
+    return TypeSpec(ParamTypeSpec(Unescape(signature.substr(1))));
+  }
+
+  size_t less_idx = std::string_view::npos;
+  int nesting = 0;
+  bool escaped = false;
+  for (size_t i = 0; i < signature.size(); ++i) {
+    char c = signature[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (c == '\\') {
+      escaped = true;
+    } else if (c == '<') {
+      if (nesting == 0 && less_idx == std::string_view::npos) {
+        less_idx = i;
+      }
+      nesting++;
+    } else if (c == '>') {
+      nesting--;
+      if (nesting < 0) {
+        return absl::InvalidArgumentError(
+            "Invalid type signature: extra closing >");
+      }
+    }
+  }
+  if (nesting != 0) {
+    return absl::InvalidArgumentError(
+        "Invalid type signature: mismatched brackets");
+  }
+
+  std::string name_str;
+  std::vector<TypeSpec> params;
+
+  if (less_idx != std::string_view::npos) {
+    // If the signature contains a '<', it must also contain a matching '>'.
+    if (signature.back() != '>') {
+      return absl::InvalidArgumentError(
+          "Invalid type signature: missing closing >");
+    }
+    name_str = Unescape(signature.substr(0, less_idx));
+    std::string_view params_str =
+        signature.substr(less_idx + 1, signature.size() - less_idx - 2);
+    CEL_ASSIGN_OR_RETURN(auto param_list, SplitTypeList(params_str));
+    for (std::string_view param_str : param_list) {
+      CEL_ASSIGN_OR_RETURN(auto param, ParseTypeSignature(param_str));
+      params.push_back(std::move(param));
+    }
+  } else {
+    name_str = Unescape(signature);
+  }
+
+  if (name_str == "null") return TypeSpec(NullTypeSpec());
+  if (name_str == "bool") return TypeSpec(PrimitiveType::kBool);
+  if (name_str == "int") return TypeSpec(PrimitiveType::kInt64);
+  if (name_str == "uint") return TypeSpec(PrimitiveType::kUint64);
+  if (name_str == "double") return TypeSpec(PrimitiveType::kDouble);
+  if (name_str == "string") return TypeSpec(PrimitiveType::kString);
+  if (name_str == "bytes") return TypeSpec(PrimitiveType::kBytes);
+  if (name_str == "any") return TypeSpec(WellKnownTypeSpec::kAny);
+  if (name_str == "timestamp") return TypeSpec(WellKnownTypeSpec::kTimestamp);
+  if (name_str == "duration") return TypeSpec(WellKnownTypeSpec::kDuration);
+  if (name_str == "dyn") return TypeSpec(DynTypeSpec());
+
+  if (name_str == "bool_wrapper")
+    return TypeSpec(PrimitiveTypeWrapper(PrimitiveType::kBool));
+  if (name_str == "int_wrapper")
+    return TypeSpec(PrimitiveTypeWrapper(PrimitiveType::kInt64));
+  if (name_str == "uint_wrapper")
+    return TypeSpec(PrimitiveTypeWrapper(PrimitiveType::kUint64));
+  if (name_str == "double_wrapper")
+    return TypeSpec(PrimitiveTypeWrapper(PrimitiveType::kDouble));
+  if (name_str == "string_wrapper")
+    return TypeSpec(PrimitiveTypeWrapper(PrimitiveType::kString));
+  if (name_str == "bytes_wrapper")
+    return TypeSpec(PrimitiveTypeWrapper(PrimitiveType::kBytes));
+
+  if (name_str == "list") {
+    if (params.size() > 1) {
+      return absl::InvalidArgumentError(
+          "Invalid type signature: list expects at most 1 parameter");
+    }
+    auto elem = std::make_unique<TypeSpec>(DynTypeSpec());
+    if (!params.empty()) {
+      *elem = std::move(params[0]);
+    }
+    return TypeSpec(ListTypeSpec(std::move(elem)));
+  }
+
+  if (name_str == "map") {
+    if (params.size() != 0 && params.size() != 2) {
+      return absl::InvalidArgumentError(
+          "Invalid type signature: map expects 0 or 2 parameters");
+    }
+    auto key = std::make_unique<TypeSpec>(DynTypeSpec());
+    auto value = std::make_unique<TypeSpec>(DynTypeSpec());
+    if (!params.empty()) {
+      *key = std::move(params[0]);
+    }
+    if (params.size() > 1) {
+      *value = std::move(params[1]);
+    }
+    return TypeSpec(MapTypeSpec(std::move(key), std::move(value)));
+  }
+
+  if (name_str == "function") {
+    auto result_type = std::make_unique<TypeSpec>(DynTypeSpec());
+    std::vector<TypeSpec> arg_types;
+    if (!params.empty()) {
+      result_type = std::make_unique<TypeSpec>(std::move(params[0]));
+      for (size_t i = 1; i < params.size(); ++i) {
+        arg_types.push_back(std::move(params[i]));
+      }
+    }
+    return TypeSpec(
+        FunctionTypeSpec(std::move(result_type), std::move(arg_types)));
+  }
+
+  return TypeSpec(AbstractType(name_str, std::move(params)));
+}
+
+absl::StatusOr<ParsedFunctionOverload> ParseFunctionSignature(
+    std::string_view signature) {
+  if (signature.empty()) {
+    return absl::InvalidArgumentError("Empty function signature");
+  }
+
+  size_t paren_idx = std::string_view::npos;
+  int nesting = 0;
+  bool escaped = false;
+  for (size_t i = 0; i < signature.size(); ++i) {
+    char c = signature[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (c == '\\') {
+      escaped = true;
+    } else if (c == '<') {
+      nesting++;
+    } else if (c == '>') {
+      nesting--;
+      if (nesting < 0) {
+        return absl::InvalidArgumentError(
+            "Invalid function signature: extra closing >");
+      }
+    } else if (c == '(' && nesting == 0) {
+      paren_idx = i;
+      break;
+    }
+  }
+
+  if (paren_idx == std::string_view::npos || signature.back() != ')') {
+    return absl::InvalidArgumentError("Invalid function signature");
+  }
+
+  std::string_view prefix = signature.substr(0, paren_idx);
+  std::string_view args_str =
+      signature.substr(paren_idx + 1, signature.size() - paren_idx - 2);
+
+  std::vector<TypeSpec> arg_types;
+  ParsedFunctionOverload out;
+
+  size_t dot_idx = std::string_view::npos;
+  nesting = 0;
+  escaped = false;
+  for (size_t i = 0; i < prefix.size(); ++i) {
+    char c = prefix[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (c == '\\') {
+      escaped = true;
+    } else if (c == '<') {
+      nesting++;
+    } else if (c == '>') {
+      nesting--;
+      if (nesting < 0) {
+        return absl::InvalidArgumentError(
+            "Invalid function signature: extra closing > in prefix");
+      }
+    } else if (c == '.' && nesting == 0) {
+      dot_idx = i;
+    }
+  }
+  if (nesting != 0) {
+    return absl::InvalidArgumentError(
+        "Invalid function signature: mismatched brackets in prefix");
+  }
+
+  if (dot_idx != std::string_view::npos) {
+    out.is_member = true;
+    std::string_view receiver_str = prefix.substr(0, dot_idx);
+    std::string_view func_str = prefix.substr(dot_idx + 1);
+
+    CEL_ASSIGN_OR_RETURN(auto receiver_param, ParseTypeSignature(receiver_str));
+    arg_types.push_back(std::move(receiver_param));
+    out.function_name = Unescape(func_str);
+  } else {
+    out.is_member = false;
+    out.function_name = Unescape(prefix);
+  }
+
+  if (out.function_name.empty()) {
+    return absl::InvalidArgumentError(
+        "Invalid function signature: empty function name");
+  }
+
+  if (!args_str.empty()) {
+    CEL_ASSIGN_OR_RETURN(auto arg_list, SplitTypeList(args_str));
+    for (std::string_view arg_str : arg_list) {
+      CEL_ASSIGN_OR_RETURN(auto arg_param, ParseTypeSignature(arg_str));
+      arg_types.push_back(std::move(arg_param));
+    }
+  }
+
+  auto result_type = std::make_unique<TypeSpec>(DynTypeSpec());
+  out.signature_type =
+      TypeSpec(FunctionTypeSpec(std::move(result_type), std::move(arg_types)));
+
+  return out;
+}
+
+absl::StatusOr<Type> ConvertTypeSpecToType(const TypeSpec& type_spec,
+                                           google::protobuf::Arena* arena,
+                                           const google::protobuf::DescriptorPool& pool) {
+  if (type_spec.has_null()) return Type(NullType{});
+  if (type_spec.has_dyn()) return Type(DynType{});
+
+  if (type_spec.has_primitive()) {
+    switch (type_spec.primitive()) {
+      case PrimitiveType::kBool:
+        return Type(BoolType{});
+      case PrimitiveType::kInt64:
+        return Type(IntType{});
+      case PrimitiveType::kUint64:
+        return Type(UintType{});
+      case PrimitiveType::kDouble:
+        return Type(DoubleType{});
+      case PrimitiveType::kString:
+        return Type(StringType{});
+      case PrimitiveType::kBytes:
+        return Type(BytesType{});
+      default:
+        return absl::InvalidArgumentError("Unsupported primitive type");
+    }
+  }
+
+  if (type_spec.has_well_known()) {
+    switch (type_spec.well_known()) {
+      case WellKnownTypeSpec::kAny:
+        return Type(AnyType{});
+      case WellKnownTypeSpec::kTimestamp:
+        return Type(TimestampType{});
+      case WellKnownTypeSpec::kDuration:
+        return Type(DurationType{});
+      default:
+        return absl::InvalidArgumentError("Unsupported well-known type");
+    }
+  }
+
+  if (type_spec.has_wrapper()) {
+    switch (type_spec.wrapper()) {
+      case PrimitiveType::kBool:
+        return Type(BoolWrapperType{});
+      case PrimitiveType::kInt64:
+        return Type(IntWrapperType{});
+      case PrimitiveType::kUint64:
+        return Type(UintWrapperType{});
+      case PrimitiveType::kDouble:
+        return Type(DoubleWrapperType{});
+      case PrimitiveType::kString:
+        return Type(StringWrapperType{});
+      case PrimitiveType::kBytes:
+        return Type(BytesWrapperType{});
+      default:
+        return absl::InvalidArgumentError("Unsupported wrapper type");
+    }
+  }
+
+  if (type_spec.has_list_type()) {
+    CEL_ASSIGN_OR_RETURN(
+        auto elem_type,
+        ConvertTypeSpecToType(type_spec.list_type().elem_type(), arena, pool));
+    return Type(ListType(arena, elem_type));
+  }
+
+  if (type_spec.has_map_type()) {
+    CEL_ASSIGN_OR_RETURN(
+        auto key_type,
+        ConvertTypeSpecToType(type_spec.map_type().key_type(), arena, pool));
+    CEL_ASSIGN_OR_RETURN(
+        auto value_type,
+        ConvertTypeSpecToType(type_spec.map_type().value_type(), arena, pool));
+    return Type(MapType(arena, key_type, value_type));
+  }
+
+  if (type_spec.has_function()) {
+    const auto& func_spec = type_spec.function();
+    CEL_ASSIGN_OR_RETURN(
+        auto result_type,
+        ConvertTypeSpecToType(func_spec.result_type(), arena, pool));
+    std::vector<Type> arg_types;
+    for (const auto& arg_spec : func_spec.arg_types()) {
+      CEL_ASSIGN_OR_RETURN(auto arg_type,
+                           ConvertTypeSpecToType(arg_spec, arena, pool));
+      arg_types.push_back(std::move(arg_type));
+    }
+    return Type(FunctionType(arena, result_type, arg_types));
+  }
+
+  if (type_spec.has_type_param()) {
+    const std::string& name = type_spec.type_param().type();
+    auto* allocated_name = google::protobuf::Arena::Create<std::string>(arena, name);
+    return Type(TypeParamType(absl::string_view(*allocated_name)));
+  }
+
+  if (type_spec.has_abstract_type()) {
+    const std::string& name = type_spec.abstract_type().name();
+
+    // Check if it's a message type in the pool
+    const google::protobuf::Descriptor* descriptor = pool.FindMessageTypeByName(name);
+    if (descriptor != nullptr) {
+      return Type::Message(descriptor);
+    }
+
+    // Otherwise fallback to OpaqueType
+    std::vector<Type> params;
+    for (const auto& param_spec : type_spec.abstract_type().parameter_types()) {
+      CEL_ASSIGN_OR_RETURN(auto param,
+                           ConvertTypeSpecToType(param_spec, arena, pool));
+      params.push_back(std::move(param));
+    }
+    auto* allocated_name = google::protobuf::Arena::Create<std::string>(arena, name);
+    return Type(OpaqueType(arena, absl::string_view(*allocated_name), params));
+  }
+
+  return absl::InvalidArgumentError("Unknown TypeSpec kind");
+}
+
+absl::StatusOr<Type> ParseType(std::string_view signature, google::protobuf::Arena* arena,
+                               const google::protobuf::DescriptorPool& pool) {
+  CEL_ASSIGN_OR_RETURN(auto type_spec, ParseTypeSignature(signature));
+  return ConvertTypeSpecToType(type_spec, arena, pool);
+}
+
 }  // namespace cel::common_internal
diff --git a/common/internal/signature.h b/common/internal/signature.h
index 3f31d8fd1..5931f1b97 100644
--- a/common/internal/signature.h
+++ b/common/internal/signature.h
@@ -20,7 +20,10 @@
 #include <vector>
 
 #include "absl/status/statusor.h"
+#include "common/ast.h"
 #include "common/type.h"
+#include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
 
 namespace cel::common_internal {
 
@@ -56,6 +59,38 @@ absl::StatusOr<std::string> MakeOverloadSignature(
     std::string_view function_name, const std::vector<Type>& args,
     bool is_member);
 
+// Parses a string type signature directly into the canonical pure C++
+// intermediate AST node `cel::TypeSpec`.
+absl::StatusOr<TypeSpec> ParseTypeSignature(std::string_view signature);
+
+// Converts a `TypeSpec` into a `cel::Type`.
+absl::StatusOr<Type> ConvertTypeSpecToType(const TypeSpec& type_spec,
+                                           google::protobuf::Arena* arena,
+                                           const google::protobuf::DescriptorPool& pool);
+
+// Parses a string type signature directly into a `cel::Type`.
+absl::StatusOr<Type> ParseType(std::string_view signature, google::protobuf::Arena* arena,
+                               const google::protobuf::DescriptorPool& pool);
+
+// A parsed function overload signature with the function name, flag for member
+// function, and the function signature type.
+struct ParsedFunctionOverload {
+  std::string function_name;
+  bool is_member = false;
+  TypeSpec signature_type;
+
+  bool operator==(const ParsedFunctionOverload& other) const {
+    return function_name == other.function_name &&
+           is_member == other.is_member &&
+           signature_type == other.signature_type;
+  }
+};
+
+// Parses a string function overload signature directly into a
+// `cel::TypeSpec` configured as a `FunctionTypeSpec`.
+absl::StatusOr<ParsedFunctionOverload> ParseFunctionSignature(
+    std::string_view signature);
+
 }  // namespace cel::common_internal
 
 #endif  // THIRD_PARTY_CEL_CPP_COMMON_INTERNAL_SIGNATURE_H_
diff --git a/common/internal/signature_test.cc b/common/internal/signature_test.cc
index 8e41c70fb..c9458d0ee 100644
--- a/common/internal/signature_test.cc
+++ b/common/internal/signature_test.cc
@@ -13,13 +13,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <cstddef>
 #include <string>
 #include <vector>
 
 #include "absl/base/no_destructor.h"
 #include "absl/status/status.h"
+#include "absl/status/status_matchers.h"
 #include "absl/status/statusor.h"
+#include "common/ast.h"
 #include "common/type.h"
+#include "common/type_kind.h"
 #include "internal/testing.h"
 #include "internal/testing_descriptor_pool.h"
 #include "google/protobuf/arena.h"
@@ -245,5 +249,184 @@ std::vector<OverloadSignatureTestCase> GetOverloadSignatureTestCases() {
 INSTANTIATE_TEST_SUITE_P(OverloadIdTest, OverloadSignatureTest,
                          ValuesIn(GetOverloadSignatureTestCases()));
 
+TEST(ParseSignatureTest, ProtoParsing) {
+  auto t1 = ParseTypeSignature("int");
+  ASSERT_THAT(t1, ::absl_testing::IsOk());
+  EXPECT_EQ(t1->primitive(), PrimitiveType::kInt64);
+
+  auto t2 = ParseTypeSignature("list<~A>");
+  ASSERT_THAT(t2, ::absl_testing::IsOk());
+  EXPECT_TRUE(t2->has_list_type());
+
+  auto t3 = ParseTypeSignature(R"(~abc\)");
+  ASSERT_THAT(t3, ::absl_testing::IsOk());
+  EXPECT_EQ(t3->type_param(), ParamTypeSpec(R"(abc\)"));
+}
+
+TEST(ParseSignatureTest, FunctionParsing) {
+  auto f1 = ParseFunctionSignature("hello(string)");
+  ASSERT_THAT(f1, ::absl_testing::IsOk());
+  EXPECT_TRUE(f1->signature_type.has_function());
+  EXPECT_EQ(f1->signature_type.function().arg_types().size(), 1);
+}
+
+TEST(ParseSignatureTest, ParsingErrors) {
+  EXPECT_THAT(ParseTypeSignature("list<int>>"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("extra closing >")));
+  EXPECT_THAT(ParseTypeSignature("list<list<int>"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("mismatched brackets")));
+  EXPECT_THAT(ParseTypeSignature("list><"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("extra closing >")));
+
+  EXPECT_THAT(ParseFunctionSignature("hello(list<int>>)"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("extra closing >")));
+  EXPECT_THAT(ParseFunctionSignature("hello(list<list<int>)"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("mismatched brackets")));
+
+  EXPECT_THAT(ParseTypeSignature("list<int,string>"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("list expects at most 1 parameter")));
+  EXPECT_THAT(ParseTypeSignature("map<int>"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("map expects 0 or 2 parameters")));
+  EXPECT_THAT(ParseTypeSignature("map<int,string,dyn>"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("map expects 0 or 2 parameters")));
+
+  EXPECT_THAT(ParseFunctionSignature("()"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("empty function name")));
+  EXPECT_THAT(ParseFunctionSignature("string.()"),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("empty function name")));
+}
+
+void VerifyParsedMatchesType(const TypeSpec& parsed, const Type& original) {
+  switch (original.kind()) {
+    case TypeKind::kDyn:
+      EXPECT_TRUE(parsed.has_dyn());
+      break;
+    case TypeKind::kNull:
+      EXPECT_TRUE(parsed.has_null());
+      break;
+    case TypeKind::kBool:
+      EXPECT_EQ(parsed.primitive(), PrimitiveType::kBool);
+      break;
+    case TypeKind::kInt:
+      EXPECT_EQ(parsed.primitive(), PrimitiveType::kInt64);
+      break;
+    case TypeKind::kUint:
+      EXPECT_EQ(parsed.primitive(), PrimitiveType::kUint64);
+      break;
+    case TypeKind::kDouble:
+      EXPECT_EQ(parsed.primitive(), PrimitiveType::kDouble);
+      break;
+    case TypeKind::kString:
+      EXPECT_EQ(parsed.primitive(), PrimitiveType::kString);
+      break;
+    case TypeKind::kBytes:
+      EXPECT_EQ(parsed.primitive(), PrimitiveType::kBytes);
+      break;
+    case TypeKind::kAny:
+      EXPECT_EQ(parsed.well_known(), WellKnownTypeSpec::kAny);
+      break;
+    case TypeKind::kTimestamp:
+      EXPECT_EQ(parsed.well_known(), WellKnownTypeSpec::kTimestamp);
+      break;
+    case TypeKind::kDuration:
+      EXPECT_EQ(parsed.well_known(), WellKnownTypeSpec::kDuration);
+      break;
+    case TypeKind::kList:
+      EXPECT_TRUE(parsed.has_list_type());
+      if (!original.GetParameters().empty()) {
+        VerifyParsedMatchesType(parsed.list_type().elem_type(),
+                                original.GetParameters()[0]);
+      }
+      break;
+    case TypeKind::kMap:
+      EXPECT_TRUE(parsed.has_map_type());
+      if (!original.GetParameters().empty()) {
+        VerifyParsedMatchesType(parsed.map_type().key_type(),
+                                original.GetParameters()[0]);
+      }
+      if (original.GetParameters().size() > 1) {
+        VerifyParsedMatchesType(parsed.map_type().value_type(),
+                                original.GetParameters()[1]);
+      }
+      break;
+    case TypeKind::kBoolWrapper:
+    case TypeKind::kIntWrapper:
+    case TypeKind::kUintWrapper:
+    case TypeKind::kDoubleWrapper:
+    case TypeKind::kStringWrapper:
+    case TypeKind::kBytesWrapper:
+      EXPECT_TRUE(parsed.has_wrapper());
+      break;
+    case TypeKind::kTypeParam:
+      EXPECT_TRUE(parsed.has_type_param());
+      break;
+    default:
+      EXPECT_TRUE(parsed.has_abstract_type());
+      break;
+  }
+}
+
+TEST_P(TypeSignatureTest, ExhaustiveParseCheck) {
+  const auto& param = GetParam();
+  if (!param.expected_signature.empty()) {
+    auto parsed = ParseTypeSignature(param.expected_signature);
+    ASSERT_THAT(parsed, ::absl_testing::IsOk());
+    VerifyParsedMatchesType(*parsed, param.type);
+  }
+}
+
+void VerifyTypesEqual(const Type& lhs, const Type& rhs) {
+  EXPECT_EQ(lhs.kind(), rhs.kind());
+  if (lhs.kind() != rhs.kind()) return;
+
+  if (lhs.kind() == TypeKind::kOpaque || lhs.kind() == TypeKind::kTypeParam) {
+    EXPECT_EQ(lhs.name(), rhs.name());
+  }
+
+  const auto& lhs_params = lhs.GetParameters();
+  const auto& rhs_params = rhs.GetParameters();
+  EXPECT_EQ(lhs_params.size(), rhs_params.size());
+  if (lhs_params.size() == rhs_params.size()) {
+    for (size_t i = 0; i < lhs_params.size(); ++i) {
+      VerifyTypesEqual(lhs_params[i], rhs_params[i]);
+    }
+  }
+}
+
+TEST_P(TypeSignatureTest, ParseTypeCheck) {
+  const auto& param = GetParam();
+  if (!param.expected_signature.empty() && param.expected_error.empty()) {
+    auto parsed = ParseType(param.expected_signature, GetTestArena(),
+                            *GetTestingDescriptorPool());
+    ASSERT_THAT(parsed, ::absl_testing::IsOk());
+    VerifyTypesEqual(*parsed, param.type);
+  }
+}
+
+TEST_P(OverloadSignatureTest, ExhaustiveFunctionParseCheck) {
+  const auto& param = GetParam();
+  if (!param.expected_signature.empty()) {
+    auto parsed = ParseFunctionSignature(param.expected_signature);
+    ASSERT_THAT(parsed, ::absl_testing::IsOk());
+    EXPECT_EQ(parsed->function_name, param.function_name);
+    EXPECT_EQ(parsed->is_member, param.is_member);
+    EXPECT_TRUE(parsed->signature_type.has_function());
+    const auto& func = parsed->signature_type.function();
+    for (size_t i = 0; i < param.args.size(); ++i) {
+      VerifyParsedMatchesType(func.arg_types()[i], param.args[i]);
+    }
+  }
+}
+
 }  // namespace
 }  // namespace cel::common_internal