basedpyright 1.10.3 → 1.10.4

package/dist/typeshed-fallback/stubs/protobuf/google/protobuf/descriptor_pb2.pyi

@@ -9,6 +9,7 @@ The messages in this file describe the definitions found in .proto files.
 A valid .proto file can be translated directly to a FileDescriptorProto
 without any other information (e.g. without reading its imports).
 """
+
 import builtins
 import collections.abc
 import sys
@@ -26,7 +27,75 @@ else:
 
 DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
 
-@typing_extensions.final
+class _Edition:
+    ValueType = typing.NewType("ValueType", builtins.int)
+    V: typing_extensions.TypeAlias = ValueType
+
+class _EditionEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Edition.ValueType], builtins.type):
+    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+    EDITION_UNKNOWN: _Edition.ValueType  # 0
+    """A placeholder for an unknown edition value."""
+    EDITION_PROTO2: _Edition.ValueType  # 998
+    """Legacy syntax "editions".  These pre-date editions, but behave much like
+    distinct editions.  These can't be used to specify the edition of proto
+    files, but feature definitions must supply proto2/proto3 defaults for
+    backwards compatibility.
+    """
+    EDITION_PROTO3: _Edition.ValueType  # 999
+    EDITION_2023: _Edition.ValueType  # 1000
+    """Editions that have been released.  The specific values are arbitrary and
+    should not be depended on, but they will always be time-ordered for easy
+    comparison.
+    """
+    EDITION_2024: _Edition.ValueType  # 1001
+    EDITION_1_TEST_ONLY: _Edition.ValueType  # 1
+    """Placeholder editions for testing feature resolution.  These should not be
+    used or relyed on outside of tests.
+    """
+    EDITION_2_TEST_ONLY: _Edition.ValueType  # 2
+    EDITION_99997_TEST_ONLY: _Edition.ValueType  # 99997
+    EDITION_99998_TEST_ONLY: _Edition.ValueType  # 99998
+    EDITION_99999_TEST_ONLY: _Edition.ValueType  # 99999
+    EDITION_MAX: _Edition.ValueType  # 2147483647
+    """Placeholder for specifying unbounded edition support.  This should only
+    ever be used by plugins that can expect to never require any changes to
+    support a new edition.
+    """
+
+class Edition(_Edition, metaclass=_EditionEnumTypeWrapper):
+    """The full set of known editions."""
+
+EDITION_UNKNOWN: Edition.ValueType  # 0
+"""A placeholder for an unknown edition value."""
+EDITION_PROTO2: Edition.ValueType  # 998
+"""Legacy syntax "editions".  These pre-date editions, but behave much like
+distinct editions.  These can't be used to specify the edition of proto
+files, but feature definitions must supply proto2/proto3 defaults for
+backwards compatibility.
+"""
+EDITION_PROTO3: Edition.ValueType  # 999
+EDITION_2023: Edition.ValueType  # 1000
+"""Editions that have been released.  The specific values are arbitrary and
+should not be depended on, but they will always be time-ordered for easy
+comparison.
+"""
+EDITION_2024: Edition.ValueType  # 1001
+EDITION_1_TEST_ONLY: Edition.ValueType  # 1
+"""Placeholder editions for testing feature resolution.  These should not be
+used or relyed on outside of tests.
+"""
+EDITION_2_TEST_ONLY: Edition.ValueType  # 2
+EDITION_99997_TEST_ONLY: Edition.ValueType  # 99997
+EDITION_99998_TEST_ONLY: Edition.ValueType  # 99998
+EDITION_99999_TEST_ONLY: Edition.ValueType  # 99999
+EDITION_MAX: Edition.ValueType  # 2147483647
+"""Placeholder for specifying unbounded edition support.  This should only
+ever be used by plugins that can expect to never require any changes to
+support a new edition.
+"""
+global___Edition = Edition
+
+@typing.final
 class FileDescriptorSet(google.protobuf.message.Message):
     """The protocol compiler can output a FileDescriptorSet containing the .proto
     files it parses.
@@ -42,11 +111,11 @@ class FileDescriptorSet(google.protobuf.message.Message):
         *,
         file: collections.abc.Iterable[global___FileDescriptorProto] | None = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing_extensions.Literal["file", b"file"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["file", b"file"]) -> None: ...
 
 global___FileDescriptorSet = FileDescriptorSet
 
-@typing_extensions.final
+@typing.final
 class FileDescriptorProto(google.protobuf.message.Message):
     """Describes a complete .proto file."""
 
@@ -64,24 +133,37 @@ class FileDescriptorProto(google.protobuf.message.Message):
     OPTIONS_FIELD_NUMBER: builtins.int
     SOURCE_CODE_INFO_FIELD_NUMBER: builtins.int
     SYNTAX_FIELD_NUMBER: builtins.int
+    EDITION_FIELD_NUMBER: builtins.int
     name: builtins.str
     """file name, relative to root of source tree"""
     package: builtins.str
     """e.g. "foo", "foo.bar", etc."""
+    syntax: builtins.str
+    """The syntax of the proto file.
+    The supported values are "proto2", "proto3", and "editions".
+
+    If `edition` is present, this value must be "editions".
+    """
+    edition: global___Edition.ValueType
+    """The edition of the proto file."""
     @property
     def dependency(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
         """Names of files imported by this file."""
+
     @property
     def public_dependency(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
         """Indexes of the public imported files in the dependency list above."""
+
     @property
     def weak_dependency(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
         """Indexes of the weak imported files in the dependency list.
         For Google-internal migration only. Do not use.
         """
+
     @property
     def message_type(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___DescriptorProto]:
         """All top-level definitions in this file."""
+
     @property
     def enum_type(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___EnumDescriptorProto]: ...
     @property
@@ -97,10 +179,7 @@ class FileDescriptorProto(google.protobuf.message.Message):
         functionality of the descriptors -- the information is needed only by
         development tools.
         """
-    syntax: builtins.str
-    """The syntax of the proto file.
-    The supported values are "proto2" and "proto3".
-    """
+
     def __init__(
         self,
         *,
@@ -116,19 +195,20 @@ class FileDescriptorProto(google.protobuf.message.Message):
         options: global___FileOptions | None = ...,
         source_code_info: global___SourceCodeInfo | None = ...,
         syntax: builtins.str | None = ...,
+        edition: global___Edition.ValueType | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["name", b"name", "options", b"options", "package", b"package", "source_code_info", b"source_code_info", "syntax", b"syntax"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["dependency", b"dependency", "enum_type", b"enum_type", "extension", b"extension", "message_type", b"message_type", "name", b"name", "options", b"options", "package", b"package", "public_dependency", b"public_dependency", "service", b"service", "source_code_info", b"source_code_info", "syntax", b"syntax", "weak_dependency", b"weak_dependency"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["edition", b"edition", "name", b"name", "options", b"options", "package", b"package", "source_code_info", b"source_code_info", "syntax", b"syntax"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["dependency", b"dependency", "edition", b"edition", "enum_type", b"enum_type", "extension", b"extension", "message_type", b"message_type", "name", b"name", "options", b"options", "package", b"package", "public_dependency", b"public_dependency", "service", b"service", "source_code_info", b"source_code_info", "syntax", b"syntax", "weak_dependency", b"weak_dependency"]) -> None: ...
 
 global___FileDescriptorProto = FileDescriptorProto
 
-@typing_extensions.final
+@typing.final
 class DescriptorProto(google.protobuf.message.Message):
     """Describes a message type."""
 
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
-    @typing_extensions.final
+    @typing.final
     class ExtensionRange(google.protobuf.message.Message):
         DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
@@ -148,10 +228,10 @@ class DescriptorProto(google.protobuf.message.Message):
             end: builtins.int | None = ...,
             options: global___ExtensionRangeOptions | None = ...,
         ) -> None: ...
-        def HasField(self, field_name: typing_extensions.Literal["end", b"end", "options", b"options", "start", b"start"]) -> builtins.bool: ...
-        def ClearField(self, field_name: typing_extensions.Literal["end", b"end", "options", b"options", "start", b"start"]) -> None: ...
+        def HasField(self, field_name: typing.Literal["end", b"end", "options", b"options", "start", b"start"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["end", b"end", "options", b"options", "start", b"start"]) -> None: ...
 
-    @typing_extensions.final
+    @typing.final
     class ReservedRange(google.protobuf.message.Message):
         """Range of reserved tag numbers. Reserved tag numbers may not be used by
         fields or extension ranges in the same message. Reserved ranges may
@@ -172,8 +252,8 @@ class DescriptorProto(google.protobuf.message.Message):
             start: builtins.int | None = ...,
             end: builtins.int | None = ...,
         ) -> None: ...
-        def HasField(self, field_name: typing_extensions.Literal["end", b"end", "start", b"start"]) -> builtins.bool: ...
-        def ClearField(self, field_name: typing_extensions.Literal["end", b"end", "start", b"start"]) -> None: ...
+        def HasField(self, field_name: typing.Literal["end", b"end", "start", b"start"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["end", b"end", "start", b"start"]) -> None: ...
 
     NAME_FIELD_NUMBER: builtins.int
     FIELD_FIELD_NUMBER: builtins.int
@@ -207,6 +287,7 @@ class DescriptorProto(google.protobuf.message.Message):
         """Reserved field names, which may not be used by fields in the same message.
         A given name may only be reserved once.
         """
+
     def __init__(
         self,
         *,
@@ -221,29 +302,111 @@ class DescriptorProto(google.protobuf.message.Message):
         reserved_range: collections.abc.Iterable[global___DescriptorProto.ReservedRange] | None = ...,
         reserved_name: collections.abc.Iterable[builtins.str] | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["name", b"name", "options", b"options"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["enum_type", b"enum_type", "extension", b"extension", "extension_range", b"extension_range", "field", b"field", "name", b"name", "nested_type", b"nested_type", "oneof_decl", b"oneof_decl", "options", b"options", "reserved_name", b"reserved_name", "reserved_range", b"reserved_range"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["name", b"name", "options", b"options"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["enum_type", b"enum_type", "extension", b"extension", "extension_range", b"extension_range", "field", b"field", "name", b"name", "nested_type", b"nested_type", "oneof_decl", b"oneof_decl", "options", b"options", "reserved_name", b"reserved_name", "reserved_range", b"reserved_range"]) -> None: ...
 
 global___DescriptorProto = DescriptorProto
 
-@typing_extensions.final
+@typing.final
 class ExtensionRangeOptions(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
+    class _VerificationState:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _VerificationStateEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[ExtensionRangeOptions._VerificationState.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        DECLARATION: ExtensionRangeOptions._VerificationState.ValueType  # 0
+        """All the extensions of the range must be declared."""
+        UNVERIFIED: ExtensionRangeOptions._VerificationState.ValueType  # 1
+
+    class VerificationState(_VerificationState, metaclass=_VerificationStateEnumTypeWrapper):
+        """The verification state of the extension range."""
+
+    DECLARATION: ExtensionRangeOptions.VerificationState.ValueType  # 0
+    """All the extensions of the range must be declared."""
+    UNVERIFIED: ExtensionRangeOptions.VerificationState.ValueType  # 1
+
+    @typing.final
+    class Declaration(google.protobuf.message.Message):
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        NUMBER_FIELD_NUMBER: builtins.int
+        FULL_NAME_FIELD_NUMBER: builtins.int
+        TYPE_FIELD_NUMBER: builtins.int
+        RESERVED_FIELD_NUMBER: builtins.int
+        REPEATED_FIELD_NUMBER: builtins.int
+        number: builtins.int
+        """The extension number declared within the extension range."""
+        full_name: builtins.str
+        """The fully-qualified name of the extension field. There must be a leading
+        dot in front of the full name.
+        """
+        type: builtins.str
+        """The fully-qualified type name of the extension field. Unlike
+        Metadata.type, Declaration.type must have a leading dot for messages
+        and enums.
+        """
+        reserved: builtins.bool
+        """If true, indicates that the number is reserved in the extension range,
+        and any extension field with the number will fail to compile. Set this
+        when a declared extension field is deleted.
+        """
+        repeated: builtins.bool
+        """If true, indicates that the extension must be defined as repeated.
+        Otherwise the extension must be defined as optional.
+        """
+        def __init__(
+            self,
+            *,
+            number: builtins.int | None = ...,
+            full_name: builtins.str | None = ...,
+            type: builtins.str | None = ...,
+            reserved: builtins.bool | None = ...,
+            repeated: builtins.bool | None = ...,
+        ) -> None: ...
+        def HasField(self, field_name: typing.Literal["full_name", b"full_name", "number", b"number", "repeated", b"repeated", "reserved", b"reserved", "type", b"type"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["full_name", b"full_name", "number", b"number", "repeated", b"repeated", "reserved", b"reserved", "type", b"type"]) -> None: ...
+
     UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int
+    DECLARATION_FIELD_NUMBER: builtins.int
+    FEATURES_FIELD_NUMBER: builtins.int
+    VERIFICATION_FIELD_NUMBER: builtins.int
+    verification: global___ExtensionRangeOptions.VerificationState.ValueType
+    """The verification state of the range.
+    TODO: flip the default to DECLARATION once all empty ranges
+    are marked as UNVERIFIED.
+    """
     @property
     def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]:
         """The parser stores options it doesn't recognize here. See above."""
+
+    @property
+    def declaration(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ExtensionRangeOptions.Declaration]:
+        """For external users: DO NOT USE. We are in the process of open sourcing
+        extension declaration and executing internal cleanups before it can be
+        used externally.
+        """
+
+    @property
+    def features(self) -> global___FeatureSet:
+        """Any features defined in the specific edition."""
+
     def __init__(
         self,
         *,
         uninterpreted_option: collections.abc.Iterable[global___UninterpretedOption] | None = ...,
+        declaration: collections.abc.Iterable[global___ExtensionRangeOptions.Declaration] | None = ...,
+        features: global___FeatureSet | None = ...,
+        verification: global___ExtensionRangeOptions.VerificationState.ValueType | None = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing_extensions.Literal["uninterpreted_option", b"uninterpreted_option"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["features", b"features", "verification", b"verification"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["declaration", b"declaration", "features", b"features", "uninterpreted_option", b"uninterpreted_option", "verification", b"verification"]) -> None: ...
 
 global___ExtensionRangeOptions = ExtensionRangeOptions
 
-@typing_extensions.final
+@typing.final
 class FieldDescriptorProto(google.protobuf.message.Message):
     """Describes a field within a message."""
 
@@ -275,9 +438,10 @@ class FieldDescriptorProto(google.protobuf.message.Message):
         TYPE_STRING: FieldDescriptorProto._Type.ValueType  # 9
         TYPE_GROUP: FieldDescriptorProto._Type.ValueType  # 10
         """Tag-delimited aggregate.
-        Group type is deprecated and not supported in proto3. However, Proto3
+        Group type is deprecated and not supported after google.protobuf. However, Proto3
         implementations should still be able to parse the group wire format and
-        treat group fields as unknown fields.
+        treat group fields as unknown fields.  In Editions, the group wire format
+        can be enabled via the `message_encoding` feature.
         """
         TYPE_MESSAGE: FieldDescriptorProto._Type.ValueType  # 11
         """Length-delimited aggregate."""
@@ -313,9 +477,10 @@ class FieldDescriptorProto(google.protobuf.message.Message):
     TYPE_STRING: FieldDescriptorProto.Type.ValueType  # 9
     TYPE_GROUP: FieldDescriptorProto.Type.ValueType  # 10
     """Tag-delimited aggregate.
-    Group type is deprecated and not supported in proto3. However, Proto3
+    Group type is deprecated and not supported after google.protobuf. However, Proto3
     implementations should still be able to parse the group wire format and
-    treat group fields as unknown fields.
+    treat group fields as unknown fields.  In Editions, the group wire format
+    can be enabled via the `message_encoding` feature.
     """
     TYPE_MESSAGE: FieldDescriptorProto.Type.ValueType  # 11
     """Length-delimited aggregate."""
@@ -338,14 +503,22 @@ class FieldDescriptorProto(google.protobuf.message.Message):
         DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
         LABEL_OPTIONAL: FieldDescriptorProto._Label.ValueType  # 1
         """0 is reserved for errors"""
-        LABEL_REQUIRED: FieldDescriptorProto._Label.ValueType  # 2
         LABEL_REPEATED: FieldDescriptorProto._Label.ValueType  # 3
+        LABEL_REQUIRED: FieldDescriptorProto._Label.ValueType  # 2
+        """The required label is only allowed in google.protobuf.  In proto3 and Editions
+        it's explicitly prohibited.  In Editions, the `field_presence` feature
+        can be used to get this behavior.
+        """
 
     class Label(_Label, metaclass=_LabelEnumTypeWrapper): ...
     LABEL_OPTIONAL: FieldDescriptorProto.Label.ValueType  # 1
     """0 is reserved for errors"""
-    LABEL_REQUIRED: FieldDescriptorProto.Label.ValueType  # 2
     LABEL_REPEATED: FieldDescriptorProto.Label.ValueType  # 3
+    LABEL_REQUIRED: FieldDescriptorProto.Label.ValueType  # 2
+    """The required label is only allowed in google.protobuf.  In proto3 and Editions
+    it's explicitly prohibited.  In Editions, the `field_presence` feature
+    can be used to get this behavior.
+    """
 
     NAME_FIELD_NUMBER: builtins.int
     NUMBER_FIELD_NUMBER: builtins.int
@@ -392,18 +565,16 @@ class FieldDescriptorProto(google.protobuf.message.Message):
     will be used. Otherwise, it's deduced from the field's name by converting
     it to camelCase.
     """
-    @property
-    def options(self) -> global___FieldOptions: ...
     proto3_optional: builtins.bool
     """If true, this is a proto3 "optional". When a proto3 field is optional, it
     tracks presence regardless of field type.
 
-    When proto3_optional is true, this field must be belong to a oneof to
-    signal to old proto3 clients that presence is tracked for this field. This
-    oneof is known as a "synthetic" oneof, and this field must be its sole
-    member (each proto3 optional field gets its own synthetic oneof). Synthetic
-    oneofs exist in the descriptor only, and do not generate any API. Synthetic
-    oneofs must be ordered after all "real" oneofs.
+    When proto3_optional is true, this field must belong to a oneof to signal
+    to old proto3 clients that presence is tracked for this field. This oneof
+    is known as a "synthetic" oneof, and this field must be its sole member
+    (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs
+    exist in the descriptor only, and do not generate any API. Synthetic oneofs
+    must be ordered after all "real" oneofs.
 
     For message fields, proto3_optional doesn't create any semantic change,
     since non-repeated message fields always track presence. However it still
@@ -417,6 +588,8 @@ class FieldDescriptorProto(google.protobuf.message.Message):
     Proto2 optional fields do not set this flag, because they already indicate
     optional with `LABEL_OPTIONAL`.
     """
+    @property
+    def options(self) -> global___FieldOptions: ...
     def __init__(
         self,
         *,
@@ -432,12 +605,12 @@ class FieldDescriptorProto(google.protobuf.message.Message):
         options: global___FieldOptions | None = ...,
         proto3_optional: builtins.bool | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["default_value", b"default_value", "extendee", b"extendee", "json_name", b"json_name", "label", b"label", "name", b"name", "number", b"number", "oneof_index", b"oneof_index", "options", b"options", "proto3_optional", b"proto3_optional", "type", b"type", "type_name", b"type_name"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["default_value", b"default_value", "extendee", b"extendee", "json_name", b"json_name", "label", b"label", "name", b"name", "number", b"number", "oneof_index", b"oneof_index", "options", b"options", "proto3_optional", b"proto3_optional", "type", b"type", "type_name", b"type_name"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["default_value", b"default_value", "extendee", b"extendee", "json_name", b"json_name", "label", b"label", "name", b"name", "number", b"number", "oneof_index", b"oneof_index", "options", b"options", "proto3_optional", b"proto3_optional", "type", b"type", "type_name", b"type_name"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["default_value", b"default_value", "extendee", b"extendee", "json_name", b"json_name", "label", b"label", "name", b"name", "number", b"number", "oneof_index", b"oneof_index", "options", b"options", "proto3_optional", b"proto3_optional", "type", b"type", "type_name", b"type_name"]) -> None: ...
 
 global___FieldDescriptorProto = FieldDescriptorProto
 
-@typing_extensions.final
+@typing.final
 class OneofDescriptorProto(google.protobuf.message.Message):
     """Describes a oneof."""
 
@@ -454,18 +627,18 @@ class OneofDescriptorProto(google.protobuf.message.Message):
         name: builtins.str | None = ...,
         options: global___OneofOptions | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["name", b"name", "options", b"options"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["name", b"name", "options", b"options"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["name", b"name", "options", b"options"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["name", b"name", "options", b"options"]) -> None: ...
 
 global___OneofDescriptorProto = OneofDescriptorProto
 
-@typing_extensions.final
+@typing.final
 class EnumDescriptorProto(google.protobuf.message.Message):
     """Describes an enum type."""
 
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
-    @typing_extensions.final
+    @typing.final
     class EnumReservedRange(google.protobuf.message.Message):
         """Range of reserved numeric values. Reserved values may not be used by
         entries in the same enum. Reserved ranges may not overlap.
@@ -489,8 +662,8 @@ class EnumDescriptorProto(google.protobuf.message.Message):
             start: builtins.int | None = ...,
             end: builtins.int | None = ...,
         ) -> None: ...
-        def HasField(self, field_name: typing_extensions.Literal["end", b"end", "start", b"start"]) -> builtins.bool: ...
-        def ClearField(self, field_name: typing_extensions.Literal["end", b"end", "start", b"start"]) -> None: ...
+        def HasField(self, field_name: typing.Literal["end", b"end", "start", b"start"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["end", b"end", "start", b"start"]) -> None: ...
 
     NAME_FIELD_NUMBER: builtins.int
     VALUE_FIELD_NUMBER: builtins.int
@@ -508,11 +681,13 @@ class EnumDescriptorProto(google.protobuf.message.Message):
         by enum values in the same enum declaration. Reserved ranges may not
         overlap.
         """
+
     @property
     def reserved_name(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
         """Reserved enum value names, which may not be reused. A given name may only
         be reserved once.
         """
+
     def __init__(
         self,
         *,
@@ -522,12 +697,12 @@ class EnumDescriptorProto(google.protobuf.message.Message):
         reserved_range: collections.abc.Iterable[global___EnumDescriptorProto.EnumReservedRange] | None = ...,
         reserved_name: collections.abc.Iterable[builtins.str] | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["name", b"name", "options", b"options"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["name", b"name", "options", b"options", "reserved_name", b"reserved_name", "reserved_range", b"reserved_range", "value", b"value"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["name", b"name", "options", b"options"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["name", b"name", "options", b"options", "reserved_name", b"reserved_name", "reserved_range", b"reserved_range", "value", b"value"]) -> None: ...
 
 global___EnumDescriptorProto = EnumDescriptorProto
 
-@typing_extensions.final
+@typing.final
 class EnumValueDescriptorProto(google.protobuf.message.Message):
     """Describes a value within an enum."""
 
@@ -547,12 +722,12 @@ class EnumValueDescriptorProto(google.protobuf.message.Message):
         number: builtins.int | None = ...,
         options: global___EnumValueOptions | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["name", b"name", "number", b"number", "options", b"options"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["name", b"name", "number", b"number", "options", b"options"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["name", b"name", "number", b"number", "options", b"options"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["name", b"name", "number", b"number", "options", b"options"]) -> None: ...
 
 global___EnumValueDescriptorProto = EnumValueDescriptorProto
 
-@typing_extensions.final
+@typing.final
 class ServiceDescriptorProto(google.protobuf.message.Message):
     """Describes a service."""
 
@@ -573,12 +748,12 @@ class ServiceDescriptorProto(google.protobuf.message.Message):
         method: collections.abc.Iterable[global___MethodDescriptorProto] | None = ...,
         options: global___ServiceOptions | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["name", b"name", "options", b"options"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["method", b"method", "name", b"name", "options", b"options"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["name", b"name", "options", b"options"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["method", b"method", "name", b"name", "options", b"options"]) -> None: ...
 
 global___ServiceDescriptorProto = ServiceDescriptorProto
 
-@typing_extensions.final
+@typing.final
 class MethodDescriptorProto(google.protobuf.message.Message):
     """Describes a method of a service."""
 
@@ -596,12 +771,12 @@ class MethodDescriptorProto(google.protobuf.message.Message):
     FieldDescriptorProto.type_name, but must refer to a message type.
     """
     output_type: builtins.str
-    @property
-    def options(self) -> global___MethodOptions: ...
     client_streaming: builtins.bool
     """Identifies if client streams multiple client messages"""
     server_streaming: builtins.bool
     """Identifies if server streams multiple server messages"""
+    @property
+    def options(self) -> global___MethodOptions: ...
     def __init__(
         self,
         *,
@@ -612,12 +787,12 @@ class MethodDescriptorProto(google.protobuf.message.Message):
         client_streaming: builtins.bool | None = ...,
         server_streaming: builtins.bool | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["client_streaming", b"client_streaming", "input_type", b"input_type", "name", b"name", "options", b"options", "output_type", b"output_type", "server_streaming", b"server_streaming"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["client_streaming", b"client_streaming", "input_type", b"input_type", "name", b"name", "options", b"options", "output_type", b"output_type", "server_streaming", b"server_streaming"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["client_streaming", b"client_streaming", "input_type", b"input_type", "name", b"name", "options", b"options", "output_type", b"output_type", "server_streaming", b"server_streaming"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["client_streaming", b"client_streaming", "input_type", b"input_type", "name", b"name", "options", b"options", "output_type", b"output_type", "server_streaming", b"server_streaming"]) -> None: ...
 
 global___MethodDescriptorProto = MethodDescriptorProto
 
-@typing_extensions.final
+@typing.final
 class FileOptions(google.protobuf.message.Message):
     """Each of the definitions above may have "options" attached.  These are
     just annotations which may cause code to be generated slightly differently
@@ -688,7 +863,6 @@ class FileOptions(google.protobuf.message.Message):
     CC_GENERIC_SERVICES_FIELD_NUMBER: builtins.int
     JAVA_GENERIC_SERVICES_FIELD_NUMBER: builtins.int
     PY_GENERIC_SERVICES_FIELD_NUMBER: builtins.int
-    PHP_GENERIC_SERVICES_FIELD_NUMBER: builtins.int
     DEPRECATED_FIELD_NUMBER: builtins.int
     CC_ENABLE_ARENAS_FIELD_NUMBER: builtins.int
     OBJC_CLASS_PREFIX_FIELD_NUMBER: builtins.int
@@ -698,6 +872,7 @@ class FileOptions(google.protobuf.message.Message):
     PHP_NAMESPACE_FIELD_NUMBER: builtins.int
     PHP_METADATA_NAMESPACE_FIELD_NUMBER: builtins.int
     RUBY_PACKAGE_FIELD_NUMBER: builtins.int
+    FEATURES_FIELD_NUMBER: builtins.int
     UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int
     java_package: builtins.str
     """Sets the Java package where classes generated from this .proto will be
@@ -752,7 +927,6 @@ class FileOptions(google.protobuf.message.Message):
     """
     java_generic_services: builtins.bool
     py_generic_services: builtins.bool
-    php_generic_services: builtins.bool
     deprecated: builtins.bool
     """Is this file deprecated?
     Depending on the target platform, this can emit Deprecated annotations
@@ -794,11 +968,16 @@ class FileOptions(google.protobuf.message.Message):
     is empty. When this option is not set, the package name will be used for
     determining the ruby package.
     """
+    @property
+    def features(self) -> global___FeatureSet:
+        """Any features defined in the specific edition."""
+
     @property
     def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]:
         """The parser stores options it doesn't recognize here.
         See the documentation for the "Options" section above.
         """
+
     def __init__(
         self,
         *,
@@ -812,7 +991,6 @@ class FileOptions(google.protobuf.message.Message):
         cc_generic_services: builtins.bool | None = ...,
         java_generic_services: builtins.bool | None = ...,
         py_generic_services: builtins.bool | None = ...,
-        php_generic_services: builtins.bool | None = ...,
         deprecated: builtins.bool | None = ...,
         cc_enable_arenas: builtins.bool | None = ...,
         objc_class_prefix: builtins.str | None = ...,
@@ -822,14 +1000,15 @@ class FileOptions(google.protobuf.message.Message):
         php_namespace: builtins.str | None = ...,
         php_metadata_namespace: builtins.str | None = ...,
         ruby_package: builtins.str | None = ...,
+        features: global___FeatureSet | None = ...,
         uninterpreted_option: collections.abc.Iterable[global___UninterpretedOption] | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["cc_enable_arenas", b"cc_enable_arenas", "cc_generic_services", b"cc_generic_services", "csharp_namespace", b"csharp_namespace", "deprecated", b"deprecated", "go_package", b"go_package", "java_generate_equals_and_hash", b"java_generate_equals_and_hash", "java_generic_services", b"java_generic_services", "java_multiple_files", b"java_multiple_files", "java_outer_classname", b"java_outer_classname", "java_package", b"java_package", "java_string_check_utf8", b"java_string_check_utf8", "objc_class_prefix", b"objc_class_prefix", "optimize_for", b"optimize_for", "php_class_prefix", b"php_class_prefix", "php_generic_services", b"php_generic_services", "php_metadata_namespace", b"php_metadata_namespace", "php_namespace", b"php_namespace", "py_generic_services", b"py_generic_services", "ruby_package", b"ruby_package", "swift_prefix", b"swift_prefix"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["cc_enable_arenas", b"cc_enable_arenas", "cc_generic_services", b"cc_generic_services", "csharp_namespace", b"csharp_namespace", "deprecated", b"deprecated", "go_package", b"go_package", "java_generate_equals_and_hash", b"java_generate_equals_and_hash", "java_generic_services", b"java_generic_services", "java_multiple_files", b"java_multiple_files", "java_outer_classname", b"java_outer_classname", "java_package", b"java_package", "java_string_check_utf8", b"java_string_check_utf8", "objc_class_prefix", b"objc_class_prefix", "optimize_for", b"optimize_for", "php_class_prefix", b"php_class_prefix", "php_generic_services", b"php_generic_services", "php_metadata_namespace", b"php_metadata_namespace", "php_namespace", b"php_namespace", "py_generic_services", b"py_generic_services", "ruby_package", b"ruby_package", "swift_prefix", b"swift_prefix", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["cc_enable_arenas", b"cc_enable_arenas", "cc_generic_services", b"cc_generic_services", "csharp_namespace", b"csharp_namespace", "deprecated", b"deprecated", "features", b"features", "go_package", b"go_package", "java_generate_equals_and_hash", b"java_generate_equals_and_hash", "java_generic_services", b"java_generic_services", "java_multiple_files", b"java_multiple_files", "java_outer_classname", b"java_outer_classname", "java_package", b"java_package", "java_string_check_utf8", b"java_string_check_utf8", "objc_class_prefix", b"objc_class_prefix", "optimize_for", b"optimize_for", "php_class_prefix", b"php_class_prefix", "php_metadata_namespace", b"php_metadata_namespace", "php_namespace", b"php_namespace", "py_generic_services", b"py_generic_services", "ruby_package", b"ruby_package", "swift_prefix", b"swift_prefix"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["cc_enable_arenas", b"cc_enable_arenas", "cc_generic_services", b"cc_generic_services", "csharp_namespace", b"csharp_namespace", "deprecated", b"deprecated", "features", b"features", "go_package", b"go_package", "java_generate_equals_and_hash", b"java_generate_equals_and_hash", "java_generic_services", b"java_generic_services", "java_multiple_files", b"java_multiple_files", "java_outer_classname", b"java_outer_classname", "java_package", b"java_package", "java_string_check_utf8", b"java_string_check_utf8", "objc_class_prefix", b"objc_class_prefix", "optimize_for", b"optimize_for", "php_class_prefix", b"php_class_prefix", "php_metadata_namespace", b"php_metadata_namespace", "php_namespace", b"php_namespace", "py_generic_services", b"py_generic_services", "ruby_package", b"ruby_package", "swift_prefix", b"swift_prefix", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
 
 global___FileOptions = FileOptions
 
-@typing_extensions.final
+@typing.final
 class MessageOptions(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
@@ -837,6 +1016,8 @@ class MessageOptions(google.protobuf.message.Message):
     NO_STANDARD_DESCRIPTOR_ACCESSOR_FIELD_NUMBER: builtins.int
     DEPRECATED_FIELD_NUMBER: builtins.int
     MAP_ENTRY_FIELD_NUMBER: builtins.int
+    DEPRECATED_LEGACY_JSON_FIELD_CONFLICTS_FIELD_NUMBER: builtins.int
+    FEATURES_FIELD_NUMBER: builtins.int
     UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int
     message_set_wire_format: builtins.bool
     """Set true to use the old proto1 MessageSet wire format for extensions.
@@ -892,9 +1073,26 @@ class MessageOptions(google.protobuf.message.Message):
     instead. The option should only be implicitly set by the proto compiler
     parser.
     """
+    deprecated_legacy_json_field_conflicts: builtins.bool
+    """Enable the legacy handling of JSON field name conflicts.  This lowercases
+    and strips underscored from the fields before comparison in proto3 only.
+    The new behavior takes `json_name` into account and applies to proto2 as
+    well.
+
+    This should only be used as a temporary measure against broken builds due
+    to the change in behavior for JSON field name conflicts.
+
+    TODO This is legacy behavior we plan to remove once downstream
+    teams have had time to migrate.
+    """
+    @property
+    def features(self) -> global___FeatureSet:
+        """Any features defined in the specific edition."""
+
     @property
     def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]:
         """The parser stores options it doesn't recognize here. See above."""
+
     def __init__(
         self,
         *,
@@ -902,14 +1100,16 @@ class MessageOptions(google.protobuf.message.Message):
         no_standard_descriptor_accessor: builtins.bool | None = ...,
         deprecated: builtins.bool | None = ...,
         map_entry: builtins.bool | None = ...,
+        deprecated_legacy_json_field_conflicts: builtins.bool | None = ...,
+        features: global___FeatureSet | None = ...,
         uninterpreted_option: collections.abc.Iterable[global___UninterpretedOption] | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["deprecated", b"deprecated", "map_entry", b"map_entry", "message_set_wire_format", b"message_set_wire_format", "no_standard_descriptor_accessor", b"no_standard_descriptor_accessor"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["deprecated", b"deprecated", "map_entry", b"map_entry", "message_set_wire_format", b"message_set_wire_format", "no_standard_descriptor_accessor", b"no_standard_descriptor_accessor", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["deprecated", b"deprecated", "deprecated_legacy_json_field_conflicts", b"deprecated_legacy_json_field_conflicts", "features", b"features", "map_entry", b"map_entry", "message_set_wire_format", b"message_set_wire_format", "no_standard_descriptor_accessor", b"no_standard_descriptor_accessor"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["deprecated", b"deprecated", "deprecated_legacy_json_field_conflicts", b"deprecated_legacy_json_field_conflicts", "features", b"features", "map_entry", b"map_entry", "message_set_wire_format", b"message_set_wire_format", "no_standard_descriptor_accessor", b"no_standard_descriptor_accessor", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
 
 global___MessageOptions = MessageOptions
 
-@typing_extensions.final
+@typing.final
 class FieldOptions(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
@@ -922,12 +1122,26 @@ class FieldOptions(google.protobuf.message.Message):
         STRING: FieldOptions._CType.ValueType  # 0
         """Default mode."""
         CORD: FieldOptions._CType.ValueType  # 1
+        """The option [ctype=CORD] may be applied to a non-repeated field of type
+        "bytes". It indicates that in C++, the data should be stored in a Cord
+        instead of a string.  For very large strings, this may reduce memory
+        fragmentation. It may also allow better performance when parsing from a
+        Cord, or when parsing with aliasing enabled, as the parsed Cord may then
+        alias the original buffer.
+        """
         STRING_PIECE: FieldOptions._CType.ValueType  # 2
 
     class CType(_CType, metaclass=_CTypeEnumTypeWrapper): ...
     STRING: FieldOptions.CType.ValueType  # 0
     """Default mode."""
     CORD: FieldOptions.CType.ValueType  # 1
+    """The option [ctype=CORD] may be applied to a non-repeated field of type
+    "bytes". It indicates that in C++, the data should be stored in a Cord
+    instead of a string.  For very large strings, this may reduce memory
+    fragmentation. It may also allow better performance when parsing from a
+    Cord, or when parsing with aliasing enabled, as the parsed Cord may then
+    alias the original buffer.
+    """
     STRING_PIECE: FieldOptions.CType.ValueType  # 2
 
     class _JSType:
@@ -951,6 +1165,79 @@ class FieldOptions(google.protobuf.message.Message):
     JS_NUMBER: FieldOptions.JSType.ValueType  # 2
     """Use JavaScript numbers."""
 
+    class _OptionRetention:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _OptionRetentionEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[FieldOptions._OptionRetention.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        RETENTION_UNKNOWN: FieldOptions._OptionRetention.ValueType  # 0
+        RETENTION_RUNTIME: FieldOptions._OptionRetention.ValueType  # 1
+        RETENTION_SOURCE: FieldOptions._OptionRetention.ValueType  # 2
+
+    class OptionRetention(_OptionRetention, metaclass=_OptionRetentionEnumTypeWrapper):
+        """If set to RETENTION_SOURCE, the option will be omitted from the binary.
+        Note: as of January 2023, support for this is in progress and does not yet
+        have an effect (b/264593489).
+        """
+
+    RETENTION_UNKNOWN: FieldOptions.OptionRetention.ValueType  # 0
+    RETENTION_RUNTIME: FieldOptions.OptionRetention.ValueType  # 1
+    RETENTION_SOURCE: FieldOptions.OptionRetention.ValueType  # 2
+
+    class _OptionTargetType:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _OptionTargetTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[FieldOptions._OptionTargetType.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        TARGET_TYPE_UNKNOWN: FieldOptions._OptionTargetType.ValueType  # 0
+        TARGET_TYPE_FILE: FieldOptions._OptionTargetType.ValueType  # 1
+        TARGET_TYPE_EXTENSION_RANGE: FieldOptions._OptionTargetType.ValueType  # 2
+        TARGET_TYPE_MESSAGE: FieldOptions._OptionTargetType.ValueType  # 3
+        TARGET_TYPE_FIELD: FieldOptions._OptionTargetType.ValueType  # 4
+        TARGET_TYPE_ONEOF: FieldOptions._OptionTargetType.ValueType  # 5
+        TARGET_TYPE_ENUM: FieldOptions._OptionTargetType.ValueType  # 6
+        TARGET_TYPE_ENUM_ENTRY: FieldOptions._OptionTargetType.ValueType  # 7
+        TARGET_TYPE_SERVICE: FieldOptions._OptionTargetType.ValueType  # 8
+        TARGET_TYPE_METHOD: FieldOptions._OptionTargetType.ValueType  # 9
+
+    class OptionTargetType(_OptionTargetType, metaclass=_OptionTargetTypeEnumTypeWrapper):
+        """This indicates the types of entities that the field may apply to when used
+        as an option. If it is unset, then the field may be freely used as an
+        option on any kind of entity. Note: as of January 2023, support for this is
+        in progress and does not yet have an effect (b/264593489).
+        """
+
+    TARGET_TYPE_UNKNOWN: FieldOptions.OptionTargetType.ValueType  # 0
+    TARGET_TYPE_FILE: FieldOptions.OptionTargetType.ValueType  # 1
+    TARGET_TYPE_EXTENSION_RANGE: FieldOptions.OptionTargetType.ValueType  # 2
+    TARGET_TYPE_MESSAGE: FieldOptions.OptionTargetType.ValueType  # 3
+    TARGET_TYPE_FIELD: FieldOptions.OptionTargetType.ValueType  # 4
+    TARGET_TYPE_ONEOF: FieldOptions.OptionTargetType.ValueType  # 5
+    TARGET_TYPE_ENUM: FieldOptions.OptionTargetType.ValueType  # 6
+    TARGET_TYPE_ENUM_ENTRY: FieldOptions.OptionTargetType.ValueType  # 7
+    TARGET_TYPE_SERVICE: FieldOptions.OptionTargetType.ValueType  # 8
+    TARGET_TYPE_METHOD: FieldOptions.OptionTargetType.ValueType  # 9
+
+    @typing.final
+    class EditionDefault(google.protobuf.message.Message):
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        EDITION_FIELD_NUMBER: builtins.int
+        VALUE_FIELD_NUMBER: builtins.int
+        edition: global___Edition.ValueType
+        value: builtins.str
+        """Textproto value."""
+        def __init__(
+            self,
+            *,
+            edition: global___Edition.ValueType | None = ...,
+            value: builtins.str | None = ...,
+        ) -> None: ...
+        def HasField(self, field_name: typing.Literal["edition", b"edition", "value", b"value"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["edition", b"edition", "value", b"value"]) -> None: ...
+
     CTYPE_FIELD_NUMBER: builtins.int
     PACKED_FIELD_NUMBER: builtins.int
     JSTYPE_FIELD_NUMBER: builtins.int
@@ -958,19 +1245,28 @@ class FieldOptions(google.protobuf.message.Message):
     UNVERIFIED_LAZY_FIELD_NUMBER: builtins.int
     DEPRECATED_FIELD_NUMBER: builtins.int
     WEAK_FIELD_NUMBER: builtins.int
+    DEBUG_REDACT_FIELD_NUMBER: builtins.int
+    RETENTION_FIELD_NUMBER: builtins.int
+    TARGETS_FIELD_NUMBER: builtins.int
+    EDITION_DEFAULTS_FIELD_NUMBER: builtins.int
+    FEATURES_FIELD_NUMBER: builtins.int
     UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int
     ctype: global___FieldOptions.CType.ValueType
     """The ctype option instructs the C++ code generator to use a different
     representation of the field than it normally would.  See the specific
-    options below.  This option is not yet implemented in the open source
-    release -- sorry, we'll try to include it in a future version!
+    options below.  This option is only implemented to support use of
+    [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of
+    type "bytes" in the open source release -- sorry, we'll try to include
+    other types in a future version!
     """
     packed: builtins.bool
     """The packed option can be enabled for repeated primitive fields to enable
     a more efficient representation on the wire. Rather than repeatedly
     writing the tag and type for each element, the entire array is encoded as
     a single length-delimited blob. In proto3, only explicit setting it to
-    false will avoid using packed encoding.
+    false will avoid using packed encoding.  This option is prohibited in
+    Editions, but the `repeated_field_encoding` feature can be used to control
+    the behavior.
     """
     jstype: global___FieldOptions.JSType.ValueType
     """The jstype option determines the JavaScript type used for values of the
@@ -1003,23 +1299,11 @@ class FieldOptions(google.protobuf.message.Message):
     call from multiple threads concurrently, while non-const methods continue
     to require exclusive access.
 
-
-    Note that implementations may choose not to check required fields within
-    a lazy sub-message.  That is, calling IsInitialized() on the outer message
-    may return true even if the inner message has missing required fields.
-    This is necessary because otherwise the inner message would have to be
-    parsed in order to perform the check, defeating the purpose of lazy
-    parsing.  An implementation which chooses not to check required fields
-    must be consistent about it.  That is, for any particular sub-message, the
-    implementation must either *always* check its required fields, or *never*
-    check its required fields, regardless of whether or not the message has
-    been parsed.
-
-    As of 2021, lazy does no correctness checks on the byte stream during
-    parsing.  This may lead to crashes if and when an invalid byte stream is
-    finally parsed upon access.
-
-    TODO(b/211906113):  Enable validation on lazy fields.
+    Note that lazy message fields are still eagerly verified to check
+    ill-formed wireformat or missing required fields. Calling IsInitialized()
+    on the outer message would fail if the inner message has missing required
+    fields. Failed verification would result in parsing failure (except when
+    uninitialized messages are acceptable).
     """
     unverified_lazy: builtins.bool
     """unverified_lazy does no correctness checks on the byte stream. This should
@@ -1034,9 +1318,23 @@ class FieldOptions(google.protobuf.message.Message):
     """
     weak: builtins.bool
     """For Google-internal migration only. Do not use."""
+    debug_redact: builtins.bool
+    """Indicate that the field value should not be printed out when using debug
+    formats, e.g. when the field contains sensitive credentials.
+    """
+    retention: global___FieldOptions.OptionRetention.ValueType
+    @property
+    def targets(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[global___FieldOptions.OptionTargetType.ValueType]: ...
+    @property
+    def edition_defaults(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___FieldOptions.EditionDefault]: ...
+    @property
+    def features(self) -> global___FeatureSet:
+        """Any features defined in the specific edition."""
+
     @property
     def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]:
         """The parser stores options it doesn't recognize here. See above."""
+
     def __init__(
         self,
         *,
@@ -1047,36 +1345,51 @@ class FieldOptions(google.protobuf.message.Message):
         unverified_lazy: builtins.bool | None = ...,
         deprecated: builtins.bool | None = ...,
         weak: builtins.bool | None = ...,
+        debug_redact: builtins.bool | None = ...,
+        retention: global___FieldOptions.OptionRetention.ValueType | None = ...,
+        targets: collections.abc.Iterable[global___FieldOptions.OptionTargetType.ValueType] | None = ...,
+        edition_defaults: collections.abc.Iterable[global___FieldOptions.EditionDefault] | None = ...,
+        features: global___FeatureSet | None = ...,
         uninterpreted_option: collections.abc.Iterable[global___UninterpretedOption] | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["ctype", b"ctype", "deprecated", b"deprecated", "jstype", b"jstype", "lazy", b"lazy", "packed", b"packed", "unverified_lazy", b"unverified_lazy", "weak", b"weak"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["ctype", b"ctype", "deprecated", b"deprecated", "jstype", b"jstype", "lazy", b"lazy", "packed", b"packed", "uninterpreted_option", b"uninterpreted_option", "unverified_lazy", b"unverified_lazy", "weak", b"weak"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["ctype", b"ctype", "debug_redact", b"debug_redact", "deprecated", b"deprecated", "features", b"features", "jstype", b"jstype", "lazy", b"lazy", "packed", b"packed", "retention", b"retention", "unverified_lazy", b"unverified_lazy", "weak", b"weak"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["ctype", b"ctype", "debug_redact", b"debug_redact", "deprecated", b"deprecated", "edition_defaults", b"edition_defaults", "features", b"features", "jstype", b"jstype", "lazy", b"lazy", "packed", b"packed", "retention", b"retention", "targets", b"targets", "uninterpreted_option", b"uninterpreted_option", "unverified_lazy", b"unverified_lazy", "weak", b"weak"]) -> None: ...
 
 global___FieldOptions = FieldOptions
 
-@typing_extensions.final
+@typing.final
 class OneofOptions(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
+    FEATURES_FIELD_NUMBER: builtins.int
     UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int
+    @property
+    def features(self) -> global___FeatureSet:
+        """Any features defined in the specific edition."""
+
     @property
     def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]:
         """The parser stores options it doesn't recognize here. See above."""
+
     def __init__(
         self,
         *,
+        features: global___FeatureSet | None = ...,
         uninterpreted_option: collections.abc.Iterable[global___UninterpretedOption] | None = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing_extensions.Literal["uninterpreted_option", b"uninterpreted_option"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["features", b"features"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["features", b"features", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
 
 global___OneofOptions = OneofOptions
 
-@typing_extensions.final
+@typing.final
 class EnumOptions(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     ALLOW_ALIAS_FIELD_NUMBER: builtins.int
     DEPRECATED_FIELD_NUMBER: builtins.int
+    DEPRECATED_LEGACY_JSON_FIELD_CONFLICTS_FIELD_NUMBER: builtins.int
+    FEATURES_FIELD_NUMBER: builtins.int
     UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int
     allow_alias: builtins.bool
     """Set this option to true to allow mapping different tag names to the same
@@ -1088,26 +1401,43 @@ class EnumOptions(google.protobuf.message.Message):
     for the enum, or it will be completely ignored; in the very least, this
     is a formalization for deprecating enums.
     """
+    deprecated_legacy_json_field_conflicts: builtins.bool
+    """Enable the legacy handling of JSON field name conflicts.  This lowercases
+    and strips underscored from the fields before comparison in proto3 only.
+    The new behavior takes `json_name` into account and applies to proto2 as
+    well.
+    TODO Remove this legacy behavior once downstream teams have
+    had time to migrate.
+    """
+    @property
+    def features(self) -> global___FeatureSet:
+        """Any features defined in the specific edition."""
+
     @property
     def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]:
         """The parser stores options it doesn't recognize here. See above."""
+
     def __init__(
         self,
         *,
         allow_alias: builtins.bool | None = ...,
         deprecated: builtins.bool | None = ...,
+        deprecated_legacy_json_field_conflicts: builtins.bool | None = ...,
+        features: global___FeatureSet | None = ...,
         uninterpreted_option: collections.abc.Iterable[global___UninterpretedOption] | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["allow_alias", b"allow_alias", "deprecated", b"deprecated"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["allow_alias", b"allow_alias", "deprecated", b"deprecated", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["allow_alias", b"allow_alias", "deprecated", b"deprecated", "deprecated_legacy_json_field_conflicts", b"deprecated_legacy_json_field_conflicts", "features", b"features"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["allow_alias", b"allow_alias", "deprecated", b"deprecated", "deprecated_legacy_json_field_conflicts", b"deprecated_legacy_json_field_conflicts", "features", b"features", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
 
 global___EnumOptions = EnumOptions
 
-@typing_extensions.final
+@typing.final
 class EnumValueOptions(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     DEPRECATED_FIELD_NUMBER: builtins.int
+    FEATURES_FIELD_NUMBER: builtins.int
+    DEBUG_REDACT_FIELD_NUMBER: builtins.int
     UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int
     deprecated: builtins.bool
     """Is this enum value deprecated?
@@ -1115,24 +1445,37 @@ class EnumValueOptions(google.protobuf.message.Message):
     for the enum value, or it will be completely ignored; in the very least,
     this is a formalization for deprecating enum values.
     """
+    debug_redact: builtins.bool
+    """Indicate that fields annotated with this enum value should not be printed
+    out when using debug formats, e.g. when the field contains sensitive
+    credentials.
+    """
+    @property
+    def features(self) -> global___FeatureSet:
+        """Any features defined in the specific edition."""
+
     @property
     def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]:
         """The parser stores options it doesn't recognize here. See above."""
+
     def __init__(
         self,
         *,
         deprecated: builtins.bool | None = ...,
+        features: global___FeatureSet | None = ...,
+        debug_redact: builtins.bool | None = ...,
         uninterpreted_option: collections.abc.Iterable[global___UninterpretedOption] | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["deprecated", b"deprecated"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["deprecated", b"deprecated", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["debug_redact", b"debug_redact", "deprecated", b"deprecated", "features", b"features"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["debug_redact", b"debug_redact", "deprecated", b"deprecated", "features", b"features", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
 
 global___EnumValueOptions = EnumValueOptions
 
-@typing_extensions.final
+@typing.final
 class ServiceOptions(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
+    FEATURES_FIELD_NUMBER: builtins.int
     DEPRECATED_FIELD_NUMBER: builtins.int
     UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int
     deprecated: builtins.bool
@@ -1146,21 +1489,27 @@ class ServiceOptions(google.protobuf.message.Message):
     for the service, or it will be completely ignored; in the very least,
     this is a formalization for deprecating services.
     """
+    @property
+    def features(self) -> global___FeatureSet:
+        """Any features defined in the specific edition."""
+
     @property
     def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]:
         """The parser stores options it doesn't recognize here. See above."""
+
     def __init__(
         self,
         *,
+        features: global___FeatureSet | None = ...,
         deprecated: builtins.bool | None = ...,
         uninterpreted_option: collections.abc.Iterable[global___UninterpretedOption] | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["deprecated", b"deprecated"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["deprecated", b"deprecated", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["deprecated", b"deprecated", "features", b"features"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["deprecated", b"deprecated", "features", b"features", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
 
 global___ServiceOptions = ServiceOptions
 
-@typing_extensions.final
+@typing.final
 class MethodOptions(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
@@ -1190,6 +1539,7 @@ class MethodOptions(google.protobuf.message.Message):
 
     DEPRECATED_FIELD_NUMBER: builtins.int
     IDEMPOTENCY_LEVEL_FIELD_NUMBER: builtins.int
+    FEATURES_FIELD_NUMBER: builtins.int
     UNINTERPRETED_OPTION_FIELD_NUMBER: builtins.int
     deprecated: builtins.bool
     """Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
@@ -1203,22 +1553,28 @@ class MethodOptions(google.protobuf.message.Message):
     this is a formalization for deprecating methods.
     """
     idempotency_level: global___MethodOptions.IdempotencyLevel.ValueType
+    @property
+    def features(self) -> global___FeatureSet:
+        """Any features defined in the specific edition."""
+
     @property
     def uninterpreted_option(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption]:
         """The parser stores options it doesn't recognize here. See above."""
+
     def __init__(
         self,
         *,
         deprecated: builtins.bool | None = ...,
         idempotency_level: global___MethodOptions.IdempotencyLevel.ValueType | None = ...,
+        features: global___FeatureSet | None = ...,
         uninterpreted_option: collections.abc.Iterable[global___UninterpretedOption] | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["deprecated", b"deprecated", "idempotency_level", b"idempotency_level"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["deprecated", b"deprecated", "idempotency_level", b"idempotency_level", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["deprecated", b"deprecated", "features", b"features", "idempotency_level", b"idempotency_level"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["deprecated", b"deprecated", "features", b"features", "idempotency_level", b"idempotency_level", "uninterpreted_option", b"uninterpreted_option"]) -> None: ...
 
 global___MethodOptions = MethodOptions
 
-@typing_extensions.final
+@typing.final
 class UninterpretedOption(google.protobuf.message.Message):
     """A message representing a option the parser does not recognize. This only
     appears in options protos created by the compiler::Parser class.
@@ -1230,7 +1586,7 @@ class UninterpretedOption(google.protobuf.message.Message):
 
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
-    @typing_extensions.final
+    @typing.final
     class NamePart(google.protobuf.message.Message):
         """The name of the uninterpreted option.  Each string represents a segment in
         a dot-separated name.  is_extension is true iff a segment represents an
@@ -1251,8 +1607,8 @@ class UninterpretedOption(google.protobuf.message.Message):
             name_part: builtins.str | None = ...,
             is_extension: builtins.bool | None = ...,
         ) -> None: ...
-        def HasField(self, field_name: typing_extensions.Literal["is_extension", b"is_extension", "name_part", b"name_part"]) -> builtins.bool: ...
-        def ClearField(self, field_name: typing_extensions.Literal["is_extension", b"is_extension", "name_part", b"name_part"]) -> None: ...
+        def HasField(self, field_name: typing.Literal["is_extension", b"is_extension", "name_part", b"name_part"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["is_extension", b"is_extension", "name_part", b"name_part"]) -> None: ...
 
     NAME_FIELD_NUMBER: builtins.int
     IDENTIFIER_VALUE_FIELD_NUMBER: builtins.int
@@ -1261,8 +1617,6 @@ class UninterpretedOption(google.protobuf.message.Message):
     DOUBLE_VALUE_FIELD_NUMBER: builtins.int
     STRING_VALUE_FIELD_NUMBER: builtins.int
     AGGREGATE_VALUE_FIELD_NUMBER: builtins.int
-    @property
-    def name(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption.NamePart]: ...
     identifier_value: builtins.str
     """The value of the uninterpreted option, in whatever type the tokenizer
     identified it as during parsing. Exactly one of these should be set.
@@ -1272,6 +1626,8 @@ class UninterpretedOption(google.protobuf.message.Message):
     double_value: builtins.float
     string_value: builtins.bytes
     aggregate_value: builtins.str
+    @property
+    def name(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___UninterpretedOption.NamePart]: ...
     def __init__(
         self,
         *,
@@ -1283,12 +1639,205 @@ class UninterpretedOption(google.protobuf.message.Message):
         string_value: builtins.bytes | None = ...,
         aggregate_value: builtins.str | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["aggregate_value", b"aggregate_value", "double_value", b"double_value", "identifier_value", b"identifier_value", "negative_int_value", b"negative_int_value", "positive_int_value", b"positive_int_value", "string_value", b"string_value"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["aggregate_value", b"aggregate_value", "double_value", b"double_value", "identifier_value", b"identifier_value", "name", b"name", "negative_int_value", b"negative_int_value", "positive_int_value", b"positive_int_value", "string_value", b"string_value"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["aggregate_value", b"aggregate_value", "double_value", b"double_value", "identifier_value", b"identifier_value", "negative_int_value", b"negative_int_value", "positive_int_value", b"positive_int_value", "string_value", b"string_value"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["aggregate_value", b"aggregate_value", "double_value", b"double_value", "identifier_value", b"identifier_value", "name", b"name", "negative_int_value", b"negative_int_value", "positive_int_value", b"positive_int_value", "string_value", b"string_value"]) -> None: ...
 
 global___UninterpretedOption = UninterpretedOption
 
-@typing_extensions.final
+@typing.final
+class FeatureSet(google.protobuf.message.Message):
+    """===================================================================
+    Features
+
+    TODO Enums in C++ gencode (and potentially other languages) are
+    not well scoped.  This means that each of the feature enums below can clash
+    with each other.  The short names we've chosen maximize call-site
+    readability, but leave us very open to this scenario.  A future feature will
+    be designed and implemented to handle this, hopefully before we ever hit a
+    conflict here.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    class _FieldPresence:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _FieldPresenceEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[FeatureSet._FieldPresence.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        FIELD_PRESENCE_UNKNOWN: FeatureSet._FieldPresence.ValueType  # 0
+        EXPLICIT: FeatureSet._FieldPresence.ValueType  # 1
+        IMPLICIT: FeatureSet._FieldPresence.ValueType  # 2
+        LEGACY_REQUIRED: FeatureSet._FieldPresence.ValueType  # 3
+
+    class FieldPresence(_FieldPresence, metaclass=_FieldPresenceEnumTypeWrapper): ...
+    FIELD_PRESENCE_UNKNOWN: FeatureSet.FieldPresence.ValueType  # 0
+    EXPLICIT: FeatureSet.FieldPresence.ValueType  # 1
+    IMPLICIT: FeatureSet.FieldPresence.ValueType  # 2
+    LEGACY_REQUIRED: FeatureSet.FieldPresence.ValueType  # 3
+
+    class _EnumType:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _EnumTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[FeatureSet._EnumType.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        ENUM_TYPE_UNKNOWN: FeatureSet._EnumType.ValueType  # 0
+        OPEN: FeatureSet._EnumType.ValueType  # 1
+        CLOSED: FeatureSet._EnumType.ValueType  # 2
+
+    class EnumType(_EnumType, metaclass=_EnumTypeEnumTypeWrapper): ...
+    ENUM_TYPE_UNKNOWN: FeatureSet.EnumType.ValueType  # 0
+    OPEN: FeatureSet.EnumType.ValueType  # 1
+    CLOSED: FeatureSet.EnumType.ValueType  # 2
+
+    class _RepeatedFieldEncoding:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _RepeatedFieldEncodingEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[FeatureSet._RepeatedFieldEncoding.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        REPEATED_FIELD_ENCODING_UNKNOWN: FeatureSet._RepeatedFieldEncoding.ValueType  # 0
+        PACKED: FeatureSet._RepeatedFieldEncoding.ValueType  # 1
+        EXPANDED: FeatureSet._RepeatedFieldEncoding.ValueType  # 2
+
+    class RepeatedFieldEncoding(_RepeatedFieldEncoding, metaclass=_RepeatedFieldEncodingEnumTypeWrapper): ...
+    REPEATED_FIELD_ENCODING_UNKNOWN: FeatureSet.RepeatedFieldEncoding.ValueType  # 0
+    PACKED: FeatureSet.RepeatedFieldEncoding.ValueType  # 1
+    EXPANDED: FeatureSet.RepeatedFieldEncoding.ValueType  # 2
+
+    class _Utf8Validation:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _Utf8ValidationEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[FeatureSet._Utf8Validation.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        UTF8_VALIDATION_UNKNOWN: FeatureSet._Utf8Validation.ValueType  # 0
+        VERIFY: FeatureSet._Utf8Validation.ValueType  # 2
+        NONE: FeatureSet._Utf8Validation.ValueType  # 3
+
+    class Utf8Validation(_Utf8Validation, metaclass=_Utf8ValidationEnumTypeWrapper): ...
+    UTF8_VALIDATION_UNKNOWN: FeatureSet.Utf8Validation.ValueType  # 0
+    VERIFY: FeatureSet.Utf8Validation.ValueType  # 2
+    NONE: FeatureSet.Utf8Validation.ValueType  # 3
+
+    class _MessageEncoding:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _MessageEncodingEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[FeatureSet._MessageEncoding.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        MESSAGE_ENCODING_UNKNOWN: FeatureSet._MessageEncoding.ValueType  # 0
+        LENGTH_PREFIXED: FeatureSet._MessageEncoding.ValueType  # 1
+        DELIMITED: FeatureSet._MessageEncoding.ValueType  # 2
+
+    class MessageEncoding(_MessageEncoding, metaclass=_MessageEncodingEnumTypeWrapper): ...
+    MESSAGE_ENCODING_UNKNOWN: FeatureSet.MessageEncoding.ValueType  # 0
+    LENGTH_PREFIXED: FeatureSet.MessageEncoding.ValueType  # 1
+    DELIMITED: FeatureSet.MessageEncoding.ValueType  # 2
+
+    class _JsonFormat:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _JsonFormatEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[FeatureSet._JsonFormat.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        JSON_FORMAT_UNKNOWN: FeatureSet._JsonFormat.ValueType  # 0
+        ALLOW: FeatureSet._JsonFormat.ValueType  # 1
+        LEGACY_BEST_EFFORT: FeatureSet._JsonFormat.ValueType  # 2
+
+    class JsonFormat(_JsonFormat, metaclass=_JsonFormatEnumTypeWrapper): ...
+    JSON_FORMAT_UNKNOWN: FeatureSet.JsonFormat.ValueType  # 0
+    ALLOW: FeatureSet.JsonFormat.ValueType  # 1
+    LEGACY_BEST_EFFORT: FeatureSet.JsonFormat.ValueType  # 2
+
+    FIELD_PRESENCE_FIELD_NUMBER: builtins.int
+    ENUM_TYPE_FIELD_NUMBER: builtins.int
+    REPEATED_FIELD_ENCODING_FIELD_NUMBER: builtins.int
+    UTF8_VALIDATION_FIELD_NUMBER: builtins.int
+    MESSAGE_ENCODING_FIELD_NUMBER: builtins.int
+    JSON_FORMAT_FIELD_NUMBER: builtins.int
+    field_presence: global___FeatureSet.FieldPresence.ValueType
+    enum_type: global___FeatureSet.EnumType.ValueType
+    repeated_field_encoding: global___FeatureSet.RepeatedFieldEncoding.ValueType
+    utf8_validation: global___FeatureSet.Utf8Validation.ValueType
+    message_encoding: global___FeatureSet.MessageEncoding.ValueType
+    json_format: global___FeatureSet.JsonFormat.ValueType
+    def __init__(
+        self,
+        *,
+        field_presence: global___FeatureSet.FieldPresence.ValueType | None = ...,
+        enum_type: global___FeatureSet.EnumType.ValueType | None = ...,
+        repeated_field_encoding: global___FeatureSet.RepeatedFieldEncoding.ValueType | None = ...,
+        utf8_validation: global___FeatureSet.Utf8Validation.ValueType | None = ...,
+        message_encoding: global___FeatureSet.MessageEncoding.ValueType | None = ...,
+        json_format: global___FeatureSet.JsonFormat.ValueType | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["enum_type", b"enum_type", "field_presence", b"field_presence", "json_format", b"json_format", "message_encoding", b"message_encoding", "repeated_field_encoding", b"repeated_field_encoding", "utf8_validation", b"utf8_validation"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["enum_type", b"enum_type", "field_presence", b"field_presence", "json_format", b"json_format", "message_encoding", b"message_encoding", "repeated_field_encoding", b"repeated_field_encoding", "utf8_validation", b"utf8_validation"]) -> None: ...
+
+global___FeatureSet = FeatureSet
+
+@typing.final
+class FeatureSetDefaults(google.protobuf.message.Message):
+    """A compiled specification for the defaults of a set of features.  These
+    messages are generated from FeatureSet extensions and can be used to seed
+    feature resolution. The resolution with this object becomes a simple search
+    for the closest matching edition, followed by proto merges.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    @typing.final
+    class FeatureSetEditionDefault(google.protobuf.message.Message):
+        """A map from every known edition with a unique set of defaults to its
+        defaults. Not all editions may be contained here.  For a given edition,
+        the defaults at the closest matching edition ordered at or before it should
+        be used.  This field must be in strict ascending order by edition.
+        """
+
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        EDITION_FIELD_NUMBER: builtins.int
+        FEATURES_FIELD_NUMBER: builtins.int
+        edition: global___Edition.ValueType
+        @property
+        def features(self) -> global___FeatureSet: ...
+        def __init__(
+            self,
+            *,
+            edition: global___Edition.ValueType | None = ...,
+            features: global___FeatureSet | None = ...,
+        ) -> None: ...
+        def HasField(self, field_name: typing.Literal["edition", b"edition", "features", b"features"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["edition", b"edition", "features", b"features"]) -> None: ...
+
+    DEFAULTS_FIELD_NUMBER: builtins.int
+    MINIMUM_EDITION_FIELD_NUMBER: builtins.int
+    MAXIMUM_EDITION_FIELD_NUMBER: builtins.int
+    minimum_edition: global___Edition.ValueType
+    """The minimum supported edition (inclusive) when this was constructed.
+    Editions before this will not have defaults.
+    """
+    maximum_edition: global___Edition.ValueType
+    """The maximum known edition (inclusive) when this was constructed. Editions
+    after this will not have reliable defaults.
+    """
+    @property
+    def defaults(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___FeatureSetDefaults.FeatureSetEditionDefault]: ...
+    def __init__(
+        self,
+        *,
+        defaults: collections.abc.Iterable[global___FeatureSetDefaults.FeatureSetEditionDefault] | None = ...,
+        minimum_edition: global___Edition.ValueType | None = ...,
+        maximum_edition: global___Edition.ValueType | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["maximum_edition", b"maximum_edition", "minimum_edition", b"minimum_edition"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["defaults", b"defaults", "maximum_edition", b"maximum_edition", "minimum_edition", b"minimum_edition"]) -> None: ...
+
+global___FeatureSetDefaults = FeatureSetDefaults
+
+@typing.final
 class SourceCodeInfo(google.protobuf.message.Message):
     """===================================================================
     Optional source code info
@@ -1299,7 +1848,7 @@ class SourceCodeInfo(google.protobuf.message.Message):
 
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
-    @typing_extensions.final
+    @typing.final
     class Location(google.protobuf.message.Message):
         DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
@@ -1308,40 +1857,6 @@ class SourceCodeInfo(google.protobuf.message.Message):
         LEADING_COMMENTS_FIELD_NUMBER: builtins.int
         TRAILING_COMMENTS_FIELD_NUMBER: builtins.int
         LEADING_DETACHED_COMMENTS_FIELD_NUMBER: builtins.int
-        @property
-        def path(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
-            """Identifies which part of the FileDescriptorProto was defined at this
-            location.
-
-            Each element is a field number or an index.  They form a path from
-            the root FileDescriptorProto to the place where the definition occurs.
-            For example, this path:
-              [ 4, 3, 2, 7, 1 ]
-            refers to:
-              file.message_type(3)  // 4, 3
-                  .field(7)         // 2, 7
-                  .name()           // 1
-            This is because FileDescriptorProto.message_type has field number 4:
-              repeated DescriptorProto message_type = 4;
-            and DescriptorProto.field has field number 2:
-              repeated FieldDescriptorProto field = 2;
-            and FieldDescriptorProto.name has field number 1:
-              optional string name = 1;
-
-            Thus, the above path gives the location of a field name.  If we removed
-            the last element:
-              [ 4, 3, 2, 7 ]
-            this path refers to the whole field declaration (from the beginning
-            of the label to the terminating semicolon).
-            """
-        @property
-        def span(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
-            """Always has exactly three or four elements: start line, start column,
-            end line (optional, otherwise assumed same as start line), end column.
-            These are packed into a single field for efficiency.  Note that line
-            and column numbers are zero-based -- typically you will want to add
-            1 to each before displaying to a user.
-            """
         leading_comments: builtins.str
         """If this SourceCodeInfo represents a complete declaration, these are any
         comments appearing before and after the declaration which appear to be
@@ -1392,6 +1907,42 @@ class SourceCodeInfo(google.protobuf.message.Message):
           // ignored detached comments.
         """
         trailing_comments: builtins.str
+        @property
+        def path(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
+            """Identifies which part of the FileDescriptorProto was defined at this
+            location.
+
+            Each element is a field number or an index.  They form a path from
+            the root FileDescriptorProto to the place where the definition appears.
+            For example, this path:
+              [ 4, 3, 2, 7, 1 ]
+            refers to:
+              file.message_type(3)  // 4, 3
+                  .field(7)         // 2, 7
+                  .name()           // 1
+            This is because FileDescriptorProto.message_type has field number 4:
+              repeated DescriptorProto message_type = 4;
+            and DescriptorProto.field has field number 2:
+              repeated FieldDescriptorProto field = 2;
+            and FieldDescriptorProto.name has field number 1:
+              optional string name = 1;
+
+            Thus, the above path gives the location of a field name.  If we removed
+            the last element:
+              [ 4, 3, 2, 7 ]
+            this path refers to the whole field declaration (from the beginning
+            of the label to the terminating semicolon).
+            """
+
+        @property
+        def span(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
+            """Always has exactly three or four elements: start line, start column,
+            end line (optional, otherwise assumed same as start line), end column.
+            These are packed into a single field for efficiency.  Note that line
+            and column numbers are zero-based -- typically you will want to add
+            1 to each before displaying to a user.
+            """
+
         @property
         def leading_detached_comments(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ...
         def __init__(
@@ -1403,8 +1954,8 @@ class SourceCodeInfo(google.protobuf.message.Message):
             trailing_comments: builtins.str | None = ...,
             leading_detached_comments: collections.abc.Iterable[builtins.str] | None = ...,
         ) -> None: ...
-        def HasField(self, field_name: typing_extensions.Literal["leading_comments", b"leading_comments", "trailing_comments", b"trailing_comments"]) -> builtins.bool: ...
-        def ClearField(self, field_name: typing_extensions.Literal["leading_comments", b"leading_comments", "leading_detached_comments", b"leading_detached_comments", "path", b"path", "span", b"span", "trailing_comments", b"trailing_comments"]) -> None: ...
+        def HasField(self, field_name: typing.Literal["leading_comments", b"leading_comments", "trailing_comments", b"trailing_comments"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["leading_comments", b"leading_comments", "leading_detached_comments", b"leading_detached_comments", "path", b"path", "span", b"span", "trailing_comments", b"trailing_comments"]) -> None: ...
 
     LOCATION_FIELD_NUMBER: builtins.int
     @property
@@ -1453,16 +2004,17 @@ class SourceCodeInfo(google.protobuf.message.Message):
           ignore those that it doesn't understand, as more types of locations could
           be recorded in the future.
         """
+
     def __init__(
         self,
         *,
         location: collections.abc.Iterable[global___SourceCodeInfo.Location] | None = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing_extensions.Literal["location", b"location"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["location", b"location"]) -> None: ...
 
 global___SourceCodeInfo = SourceCodeInfo
 
-@typing_extensions.final
+@typing.final
 class GeneratedCodeInfo(google.protobuf.message.Message):
     """Describes the relationship between generated code and its original source
     file. A GeneratedCodeInfo message is associated with only one generated
@@ -1471,19 +2023,40 @@ class GeneratedCodeInfo(google.protobuf.message.Message):
 
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
-    @typing_extensions.final
+    @typing.final
     class Annotation(google.protobuf.message.Message):
         DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
+        class _Semantic:
+            ValueType = typing.NewType("ValueType", builtins.int)
+            V: typing_extensions.TypeAlias = ValueType
+
+        class _SemanticEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[GeneratedCodeInfo.Annotation._Semantic.ValueType], builtins.type):
+            DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+            NONE: GeneratedCodeInfo.Annotation._Semantic.ValueType  # 0
+            """There is no effect or the effect is indescribable."""
+            SET: GeneratedCodeInfo.Annotation._Semantic.ValueType  # 1
+            """The element is set or otherwise mutated."""
+            ALIAS: GeneratedCodeInfo.Annotation._Semantic.ValueType  # 2
+            """An alias to the element is returned."""
+
+        class Semantic(_Semantic, metaclass=_SemanticEnumTypeWrapper):
+            """Represents the identified object's effect on the element in the original
+            .proto file.
+            """
+
+        NONE: GeneratedCodeInfo.Annotation.Semantic.ValueType  # 0
+        """There is no effect or the effect is indescribable."""
+        SET: GeneratedCodeInfo.Annotation.Semantic.ValueType  # 1
+        """The element is set or otherwise mutated."""
+        ALIAS: GeneratedCodeInfo.Annotation.Semantic.ValueType  # 2
+        """An alias to the element is returned."""
+
         PATH_FIELD_NUMBER: builtins.int
         SOURCE_FILE_FIELD_NUMBER: builtins.int
         BEGIN_FIELD_NUMBER: builtins.int
         END_FIELD_NUMBER: builtins.int
-        @property
-        def path(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
-            """Identifies the element in the original source .proto file. This field
-            is formatted the same as SourceCodeInfo.Location.path.
-            """
+        SEMANTIC_FIELD_NUMBER: builtins.int
         source_file: builtins.str
         """Identifies the filesystem path to the original source .proto."""
         begin: builtins.int
@@ -1492,9 +2065,16 @@ class GeneratedCodeInfo(google.protobuf.message.Message):
         """
         end: builtins.int
         """Identifies the ending offset in bytes in the generated code that
-        relates to the identified offset. The end offset should be one past
+        relates to the identified object. The end offset should be one past
         the last relevant byte (so the length of the text = end - begin).
         """
+        semantic: global___GeneratedCodeInfo.Annotation.Semantic.ValueType
+        @property
+        def path(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
+            """Identifies the element in the original source .proto file. This field
+            is formatted the same as SourceCodeInfo.Location.path.
+            """
+
         def __init__(
             self,
             *,
@@ -1502,9 +2082,10 @@ class GeneratedCodeInfo(google.protobuf.message.Message):
             source_file: builtins.str | None = ...,
             begin: builtins.int | None = ...,
             end: builtins.int | None = ...,
+            semantic: global___GeneratedCodeInfo.Annotation.Semantic.ValueType | None = ...,
         ) -> None: ...
-        def HasField(self, field_name: typing_extensions.Literal["begin", b"begin", "end", b"end", "source_file", b"source_file"]) -> builtins.bool: ...
-        def ClearField(self, field_name: typing_extensions.Literal["begin", b"begin", "end", b"end", "path", b"path", "source_file", b"source_file"]) -> None: ...
+        def HasField(self, field_name: typing.Literal["begin", b"begin", "end", b"end", "semantic", b"semantic", "source_file", b"source_file"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["begin", b"begin", "end", b"end", "path", b"path", "semantic", b"semantic", "source_file", b"source_file"]) -> None: ...
 
     ANNOTATION_FIELD_NUMBER: builtins.int
     @property
@@ -1512,11 +2093,12 @@ class GeneratedCodeInfo(google.protobuf.message.Message):
         """An Annotation connects some span of text in generated code to an element
         of its generating .proto file.
         """
+
     def __init__(
         self,
         *,
         annotation: collections.abc.Iterable[global___GeneratedCodeInfo.Annotation] | None = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing_extensions.Literal["annotation", b"annotation"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["annotation", b"annotation"]) -> None: ...
 
 global___GeneratedCodeInfo = GeneratedCodeInfo