reproto 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

core/reconstructor.py

@@ -15,14 +15,31 @@ from pathlib import Path
 from collections import deque
 from typing import Set, Dict, List, Optional, Tuple
 
-from parsing.java_parser import JavaParser
-from parsing.enum_parser import EnumParser
-from core.info_decoder import InfoDecoder
-from generation.proto_generator import ProtoGenerator
-from models.message_definition import MessageDefinition, EnumDefinition, EnumValueDefinition
-from utils.logger import get_logger
-from utils.file_cache import get_file_cache
-from utils.type_utils import type_mapper, naming_converter
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from ..parsing.java_parser import JavaParser
+    from ..parsing.enum_parser import EnumParser
+    from .info_decoder import InfoDecoder
+    from ..generation.proto_generator import ProtoGenerator
+    from ..models.message_definition import MessageDefinition, EnumDefinition, EnumValueDefinition
+    from ..utils.logger import get_logger
+    from ..utils.file_cache import get_file_cache
+    from ..utils.type_utils import type_mapper, naming_converter, TypeMapper, NamingConverter
+    from ..utils.builtin_proto import get_builtin_manager
+    from ..utils.type_index import get_type_index
+except ImportError:
+    # 绝对导入（开发环境）
+    from parsing.java_parser import JavaParser
+    from parsing.enum_parser import EnumParser
+    from core.info_decoder import InfoDecoder
+    from generation.proto_generator import ProtoGenerator
+    from models.message_definition import MessageDefinition, EnumDefinition, EnumValueDefinition
+    from utils.logger import get_logger
+    from utils.file_cache import get_file_cache
+    from utils.type_utils import type_mapper, naming_converter, TypeMapper, NamingConverter
+    from utils.builtin_proto import get_builtin_manager
+    from utils.type_index import get_type_index
 
 
 class JavaSourceAnalyzer:
@@ -267,6 +284,43 @@ class JavaSourceAnalyzer:
         
         return None
     
+    def _extract_constant_value(self, constant_name: str) -> Optional[int]:
+        """
+        从Java源码中提取常量值
+        
+        Args:
+            constant_name: 常量名（如 "SKIP_RECOVERY_FIELD_NUMBER"）
+            
+        Returns:
+            常量值，如果找不到则返回None
+        """
+        if not self._current_class_content:
+            return None
+        
+        # 查找常量声明模式
+        patterns = [
+            # public static final int SKIP_RECOVERY_FIELD_NUMBER = 5;
+            rf'public\s+static\s+final\s+int\s+{re.escape(constant_name)}\s*=\s*(\d+)\s*;',
+            # private static final int SKIP_RECOVERY_FIELD_NUMBER = 5;
+            rf'private\s+static\s+final\s+int\s+{re.escape(constant_name)}\s*=\s*(\d+)\s*;',
+            # static final int SKIP_RECOVERY_FIELD_NUMBER = 5;
+            rf'static\s+final\s+int\s+{re.escape(constant_name)}\s*=\s*(\d+)\s*;',
+            # final int SKIP_RECOVERY_FIELD_NUMBER = 5;
+            rf'final\s+int\s+{re.escape(constant_name)}\s*=\s*(\d+)\s*;',
+            # int SKIP_RECOVERY_FIELD_NUMBER = 5;
+            rf'int\s+{re.escape(constant_name)}\s*=\s*(\d+)\s*;',
+        ]
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, self._current_class_content)
+            if matches:
+                try:
+                    return int(matches[0])
+                except ValueError:
+                    continue
+        
+        return None
+    
     def _load_class_content(self, class_name: str) -> Optional[str]:
         """加载类的源码内容（使用缓存优化）"""
         try:
@@ -321,6 +375,9 @@ class ProtoReconstructor:
         self.java_source_analyzer = JavaSourceAnalyzer(sources_dir)
         self.info_decoder.java_source_analyzer = self.java_source_analyzer
         
+        # 初始化内置proto管理器
+        self.builtin_manager = get_builtin_manager(output_dir=str(output_dir))
+        
         # 🚀 性能优化：移除未使用的索引系统，简化代码
         # 索引系统在实际使用中被基础类型检测绕过，且构建耗时
         # 改为使用直接的文件路径构造和智能包名推断
@@ -363,7 +420,6 @@ class ProtoReconstructor:
         self._generate_all_proto_files()
         
         # 5. 输出性能统计信息
-        from utils.file_cache import get_file_cache
         file_cache = get_file_cache()
         file_cache.print_stats()
         
@@ -460,7 +516,20 @@ class ProtoReconstructor:
                 return
             
             # 3. 尝试解析为消息类
-            info_string, objects_array = self.java_parser.parse_java_file(java_file_path)
+            # 特殊处理：如果是内部类且找到的是外部类文件，需要从外部类中提取内部类信息
+            if '$' in class_name and java_file_path.stem != class_name.split('.')[-1]:
+                # 这是内部类，但找到的是外部类文件
+                inner_class_name = class_name.split('$')[-1]  # 获取内部类名
+                info_string, objects_array = self.java_parser.parse_inner_class_from_file(
+                    java_file_path, inner_class_name
+                )
+                # 为内部类创建虚拟的Java文件路径，用于字段标签提取
+                virtual_java_file_path = java_file_path.parent / f"{java_file_path.stem}${inner_class_name}.java"
+            else:
+                # 普通类或独立的内部类文件
+                info_string, objects_array = self.java_parser.parse_java_file(java_file_path)
+                virtual_java_file_path = java_file_path
+            
             if not info_string:
                 error_msg = "无法从Java文件中提取protobuf信息"
                 self.failed_classes[class_name] = error_msg
@@ -469,7 +538,7 @@ class ProtoReconstructor:
             
             # 4. 解码字节码为消息定义
             message_def = self.info_decoder.decode_message_info(
-                class_name, info_string, objects_array, java_file_path
+                class_name, info_string, objects_array, virtual_java_file_path
             )
             
             if message_def:
@@ -478,6 +547,16 @@ class ProtoReconstructor:
                 
                 # 5. 发现并添加依赖类到队列
                 self._discover_dependencies(message_def)
+                
+                # 6. 处理InfoDecoder发现的依赖类（如oneof中的类引用）
+                discovered_deps = self.info_decoder.get_discovered_dependencies()
+                for dep_class in discovered_deps:
+                    if dep_class not in self.processed_classes and dep_class not in self.pending_classes:
+                        self.pending_classes.append(dep_class)
+                        self.logger.info(f"  🔗 发现oneof依赖: {dep_class}")
+                
+                # 清理InfoDecoder的依赖记录，为下次解析做准备
+                self.info_decoder.discovered_dependencies = []
             else:
                 error_msg = "字节码解码失败，可能不是protobuf消息类"
                 self.failed_classes[class_name] = error_msg
@@ -503,11 +582,24 @@ class ProtoReconstructor:
             message_def: 消息定义对象
         """
         dependencies = self._extract_dependencies(message_def)
+        builtin_count = 0
+        
         for dep in dependencies:
-            if dep not in self.processed_classes:
+            # 检查是否为内置类型
+            if self.builtin_manager.is_builtin_type(dep):
+                # 处理内置类型依赖
+                if self.builtin_manager.ensure_builtin_proto_file(dep):
+                    self.logger.info(f"  📦 处理内置依赖: {dep}")
+                    builtin_count += 1
+                else:
+                    self.logger.error(f"  ❌ 内置依赖处理失败: {dep}")
+            elif dep not in self.processed_classes:
                 self.pending_classes.append(dep)
                 self.logger.info(f"  🔗 发现依赖: {dep}")
                 
+        if builtin_count > 0:
+            self.logger.info(f"  📊 处理了 {builtin_count} 个内置依赖")
+                
         # 处理枚举依赖
         self.logger.info(f"  🔍 开始处理枚举依赖...")
         enum_count = 0
@@ -930,20 +1022,46 @@ class ProtoReconstructor:
         if full_path.exists():
             return full_path
         
-        # 🚀 优化2：处理内部类，但避免全目录扫描
+        # 🚀 优化2：处理内部类，正确的查找顺序
         if '$' in class_name:
-            # 内部类处理：com.example.Models$Inner -> com/example/Models.java
             last_dot_index = class_name.rfind('.')
             if last_dot_index != -1:
                 package_path = class_name[:last_dot_index].replace('.', '/')
                 class_part = class_name[last_dot_index + 1:]
                 
-                # 提取外部类名（$之前的部分）
+                # 方式1：优先查找主类文件 - 内部类通常定义在主类中
+                # 如：com.example.Service$InnerClass -> 在 Service$CompleteOnboardingRequest.java 中查找
+                # 这里需要找到包含这个内部类的主类文件
+                outer_class_prefix = class_part.split('$')[0]  # Service
+                
+                # 在同一包下查找所有以外部类名开头的文件，并检查是否包含目标内部类
+                inner_class_name = class_part.split('$')[-1]  # 获取内部类名，如SkipRecovery
+                package_dir = self.sources_dir / package_path
+                if package_dir.exists():
+                    for java_file in package_dir.glob(f"{outer_class_prefix}$*.java"):
+                        self.logger.debug(f"    📁 检查主类文件: {java_file}")
+                        # 检查这个文件是否包含目标内部类
+                        if self._file_contains_inner_class(java_file, inner_class_name):
+                            self.logger.debug(f"    ✅ 找到包含内部类 {inner_class_name} 的文件: {java_file}")
+                            return java_file
+                
+                # 方式2：查找独立的内部类文件
+                # 如：com.example.Service$InnerClass -> com/example/Service$InnerClass.java
+                inner_class_file_path = f"{package_path}/{class_part}.java"
+                inner_class_full_path = self.sources_dir / inner_class_file_path
+                
+                if inner_class_full_path.exists():
+                    self.logger.debug(f"    📁 找到独立内部类文件: {inner_class_full_path}")
+                    return inner_class_full_path
+                
+                # 方式3：传统风格 - 内部类在外部类文件中（外部类本身）
+                # 如：com.example.Service$InnerClass -> com/example/Service.java
                 outer_class = class_part.split('$')[0]
                 outer_class_file_path = f"{package_path}/{outer_class}.java"
                 outer_class_full_path = self.sources_dir / outer_class_file_path
                 
                 if outer_class_full_path.exists():
+                    self.logger.debug(f"    📁 找到外部类文件: {outer_class_full_path}")
                     return outer_class_full_path
         
         # 🚀 优化3：简化文件查找逻辑，移除索引依赖
@@ -970,6 +1088,32 @@ class ProtoReconstructor:
         
         return None
     
+    def _file_contains_inner_class(self, java_file_path: Path, inner_class_name: str) -> bool:
+        """
+        检查Java文件是否包含指定的内部类定义
+        
+        Args:
+            java_file_path: Java文件路径
+            inner_class_name: 内部类名（如"SkipRecovery"）
+            
+        Returns:
+            是否包含该内部类
+        """
+        try:
+            content = java_file_path.read_text(encoding='utf-8')
+            # 查找内部类定义
+            class_pattern = rf'public\s+static\s+final\s+class\s+{re.escape(inner_class_name)}\s+extends\s+'
+            if re.search(class_pattern, content):
+                return True
+            
+            # 尝试更宽松的匹配
+            class_pattern = rf'class\s+{re.escape(inner_class_name)}\s+extends\s+'
+            return re.search(class_pattern, content) is not None
+            
+        except Exception as e:
+            self.logger.debug(f"    ❌ 检查文件 {java_file_path} 时出错: {e}")
+            return False
+    
     def _infer_full_class_name(self, simple_name: str, current_package: str) -> Optional[str]:
         """
         推断简单类名的完整包名（通用算法，适用于任何应用）
@@ -1140,8 +1284,6 @@ class ProtoReconstructor:
             是否为基础字段类型
         """
         # 🚀 性能优化：使用缓存的类型检查器，避免重复计算
-        from utils.type_utils import TypeMapper
-        
         # 直接使用统一的基础类型检查，无需额外逻辑
         return TypeMapper.is_java_basic_type(type_name)
 
@@ -1224,8 +1366,6 @@ class ProtoReconstructor:
             实际的完整类型名
         """
         # 🚀 优化：使用统一的类型检查器
-        from utils.type_utils import TypeMapper
-        
         if TypeMapper.is_java_basic_type(inferred_type):
             self.logger.debug(f"    跳过基础类型: {inferred_type}")
             return None
@@ -1236,7 +1376,6 @@ class ProtoReconstructor:
         
         try:
             # 使用索引系统进行快速查找，避免文件IO
-            from utils.type_index import get_type_index
             type_index = get_type_index(self.sources_dir)
             
             # 构造可能的完整类名
@@ -1394,5 +1533,4 @@ class ProtoReconstructor:
             蛇形命名字符串
         """
         # 🚀 优化：使用统一的命名转换器，避免重复实现
-        from utils.type_utils import NamingConverter
         return NamingConverter.to_snake_case(camel_str) 

generation/__init__.py

@@ -1,3 +1,20 @@
+"""
+代码生成模块
+
+负责将解析得到的消息定义转换为Protobuf .proto文件
+"""
+
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from .proto_generator import ProtoGenerator
+except ImportError:
+    # 绝对导入（开发环境）
+    from generation.proto_generator import ProtoGenerator
+
+__all__ = [
+    'ProtoGenerator'
+]
 
 
 

generation/proto_generator.py

@@ -10,8 +10,17 @@ Author: AI Assistant
 
 import re
 from typing import Dict, Set, List, Union
-from models.message_definition import MessageDefinition, FieldDefinition, EnumDefinition, EnumValueDefinition
-from utils.type_utils import type_mapper, naming_converter, field_name_processor
+
+# 智能导入：同时支持相对导入（包环境）和绝对导入（开发环境）
+try:
+    # 相对导入（包环境）
+    from ..models.message_definition import MessageDefinition, FieldDefinition, EnumDefinition, EnumValueDefinition
+    from ..utils.type_utils import type_mapper, naming_converter, field_name_processor
+    from ..utils.logger import get_logger
+except ImportError:
+    # 绝对导入（开发环境）
+    from models.message_definition import MessageDefinition, FieldDefinition, EnumDefinition, EnumValueDefinition
+    from utils.type_utils import type_mapper, naming_converter, field_name_processor
 
 
 class ProtoGenerator:
@@ -70,7 +79,6 @@ class ProtoGenerator:
             return '\n'.join(lines)
             
         except Exception as e:
-            from utils.logger import get_logger
             logger = get_logger("proto_generator")
             logger.error(f"❌ 生成proto文件失败 {message_def.name if message_def else 'Unknown'}: {e}")
             raise
@@ -118,7 +126,6 @@ class ProtoGenerator:
             return '\n'.join(lines)
             
         except Exception as e:
-            from utils.logger import get_logger
             logger = get_logger("proto_generator")
             logger.error(f"❌ 生成枚举proto文件失败 {enum_def.name if enum_def else 'Unknown'}: {e}")
             raise
@@ -190,7 +197,16 @@ class ProtoGenerator:
         Returns:
             消息定义的行列表
         """
-        lines = [f'message {message_def.name} {{']
+        # 清理消息名称中的$符号
+        clean_name = naming_converter.clean_proto_name(message_def.name)
+        
+        lines = []
+        
+        # 如果是内部类、匿名类或包含$的特殊类，添加原始Java类名注释
+        if message_def.full_name and ('$' in message_def.full_name or 'Anonymous' in message_def.full_name):
+            lines.append(f'// 原始Java类: {message_def.full_name}')
+        
+        lines.append(f'message {clean_name} {{')
         
         # 生成oneof字段（oneof字段内部也按tag排序）
         for oneof in message_def.oneofs:
@@ -214,7 +230,16 @@ class ProtoGenerator:
         Returns:
             枚举定义的行列表
         """
-        lines = [f'enum {enum_def.name} {{']
+        # 清理枚举名称中的$符号
+        clean_name = naming_converter.clean_proto_name(enum_def.name)
+        
+        lines = []
+        
+        # 如果是内部类、匿名类或包含$的特殊enum，添加原始Java类名注释
+        if enum_def.full_name and ('$' in enum_def.full_name or 'Anonymous' in enum_def.full_name):
+            lines.append(f'// 原始Java类: {enum_def.full_name}')
+        
+        lines.append(f'enum {clean_name} {{')
         
         # 生成枚举值（按value排序）
         sorted_values = sorted(enum_def.values, key=lambda enum_value: enum_value.value)
@@ -272,7 +297,6 @@ class ProtoGenerator:
                 return f'  {field_type} {field.name} = {field.tag};'
                 
         except Exception as e:
-            from utils.logger import get_logger
             logger = get_logger("proto_generator")
             logger.error(f"❌ 生成字段定义失败 {field.name if field else 'Unknown'}: {e}")
             raise
@@ -335,6 +359,16 @@ class ProtoGenerator:
         if field.type_name in basic_proto_types:
             return None
         
+        # 检查是否为Google Protobuf内置类型
+        try:
+            from utils.builtin_proto import get_builtin_manager
+            builtin_manager = get_builtin_manager()
+            if builtin_manager.is_builtin_type(field.type_name):
+                return builtin_manager.get_import_path(field.type_name)
+        except (ImportError, ValueError):
+            # 如果内置管理器不可用，继续使用原有逻辑
+            pass
+        
         # 处理map类型：map<string, Contact> -> 提取值类型Contact
         if field.type_name.startswith('map<'):
             # 解析map类型：map<key_type, value_type>
@@ -366,6 +400,10 @@ class ProtoGenerator:
                     # 生成枚举文件的导入路径
                     return self._class_name_to_import_path(enum_full_name)
         
+        # 优先使用字段定义中保存的完整类名信息（用于内部类等特殊情况）
+        if hasattr(field, 'full_class_name') and field.full_class_name:
+            return self._class_name_to_import_path(field.full_class_name)
+        
         # 解析完整类名（消息类型）
         full_class_name = self._resolve_full_class_name(field.type_name, current_package, all_messages)
         if full_class_name:
@@ -418,9 +456,12 @@ class ProtoGenerator:
         Returns:
             proto导入路径
         """
-        # com.example.Model -> com/example/model.proto
+        # com.example.Service$SkipRecovery -> com/example/service_skip_recovery.proto
+        # 注意：这里要使用完整的类名（包含$符号）来生成文件名，与实际文件名保持一致
         parts = class_name.split('.')
-        proto_name = self._to_snake_case(parts[-1]) + '.proto'
+        # 使用完整的类名部分（可能包含$）来生成proto文件名
+        class_part = parts[-1]
+        proto_name = self._to_snake_case(class_part) + '.proto'
         package_path = '/'.join(parts[:-1])
         return f"{package_path}/{proto_name}"
     
@@ -464,20 +505,25 @@ class ProtoGenerator:
         if field.type_name == 'message':
             return self._generate_message_type_name(field.name)
         
-        # 检查是否为枚举类型，如果是则使用原始枚举名
+        # 检查是否为枚举类型，如果是则使用清理后的枚举名
         if all_enums:
             for enum_full_name, enum_def in all_enums.items():
                 enum_class_name = enum_full_name.split('.')[-1]  # 获取类名部分
                 if field.type_name == enum_class_name:
-                    # 使用原始枚举名而不是混淆名
-                    return enum_def.name
+                    # 使用清理后的枚举名，去掉$符号
+                    return naming_converter.clean_proto_name(enum_def.name)
         
-        # 已知的具体类型名，提取简单类型名
+        # 已知的具体类型名，处理Google Protobuf类型和普通类型
         if '.' in field.type_name:
-            # 从完整类名中提取简单类型名
-            return field.type_name.split('.')[-1]
+            # 如果是Google Protobuf类型，保持完整的类型名
+            if field.type_name.startswith('google.protobuf.'):
+                return field.type_name
+            # 其他类型提取简单类型名，并清理$符号
+            simple_name = field.type_name.split('.')[-1]
+            return naming_converter.clean_proto_name(simple_name)
         else:
-            return field.type_name
+            # 清理简单类型名中的$符号
+            return naming_converter.clean_proto_name(field.type_name)
     
     def _get_basic_proto_type(self, type_name: str) -> str:
         """

include/google/protobuf/any.proto

@@ -0,0 +1,162 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option go_package = "google.golang.org/protobuf/types/known/anypb";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "AnyProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//     // or ...
+//     if (any.isSameTypeAs(Foo.getDefaultInstance())) {
+//       foo = any.unpack(Foo.getDefaultInstance());
+//     }
+//
+//  Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+//  Example 4: Pack and unpack a message in Go
+//
+//      foo := &pb.Foo{...}
+//      any, err := anypb.New(foo)
+//      if err != nil {
+//        ...
+//      }
+//      ...
+//      foo := &pb.Foo{}
+//      if err := any.UnmarshalTo(foo); err != nil {
+//        ...
+//      }
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+// JSON
+// ====
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+message Any {
+  // A URL/resource name that uniquely identifies the type of the serialized
+  // protocol buffer message. This string must contain at least
+  // one "/" character. The last segment of the URL's path must represent
+  // the fully qualified name of the type (as in
+  // `path/google.protobuf.Duration`). The name should be in a canonical form
+  // (e.g., leading "." is not accepted).
+  //
+  // In practice, teams usually precompile into the binary all types that they
+  // expect it to use in the context of Any. However, for URLs which use the
+  // scheme `http`, `https`, or no scheme, one can optionally set up a type
+  // server that maps type URLs to message definitions as follows:
+  //
+  // * If no scheme is provided, `https` is assumed.
+  // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+  //   value in binary format, or produce an error.
+  // * Applications are allowed to cache lookup results based on the
+  //   URL, or have them precompiled into a binary to avoid any
+  //   lookup. Therefore, binary compatibility needs to be preserved
+  //   on changes to types. (Use versioned type names to manage
+  //   breaking changes.)
+  //
+  // Note: this functionality is not currently available in the official
+  // protobuf release, and it is not used for type URLs beginning with
+  // type.googleapis.com. As of May 2023, there are no widely used type server
+  // implementations and no plans to implement one.
+  //
+  // Schemes other than `http`, `https` (or the empty scheme) might be
+  // used with implementation specific semantics.
+  //
+  string type_url = 1;
+
+  // Must be a valid serialized protocol buffer of the above specified type.
+  bytes value = 2;
+}