.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stubs/protobuf/google/protobuf/compiler/plugin_pb2.pyi

   1 """
   2 @generated by mypy-protobuf.  Do not edit manually!
   3 isort:skip_file
   4 """
   5 import builtins
   6 import google.protobuf.descriptor
   7 import google.protobuf.descriptor_pb2
   8 import google.protobuf.internal.containers
   9 import google.protobuf.internal.enum_type_wrapper
  10 import google.protobuf.message
  11 import typing
  12 import typing_extensions
  13
  14 DESCRIPTOR: google.protobuf.descriptor.FileDescriptor = ...
  15
  16 class Version(google.protobuf.message.Message):
  17     """The version number of protocol compiler."""
  18     DESCRIPTOR: google.protobuf.descriptor.Descriptor = ...
  19     MAJOR_FIELD_NUMBER: builtins.int
  20     MINOR_FIELD_NUMBER: builtins.int
  21     PATCH_FIELD_NUMBER: builtins.int
  22     SUFFIX_FIELD_NUMBER: builtins.int
  23     major: builtins.int = ...
  24     minor: builtins.int = ...
  25     patch: builtins.int = ...
  26     suffix: typing.Text = ...
  27     """A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
  28     be empty for mainline stable releases.
  29     """
  30
  31     def __init__(self,
  32         *,
  33         major : typing.Optional[builtins.int] = ...,
  34         minor : typing.Optional[builtins.int] = ...,
  35         patch : typing.Optional[builtins.int] = ...,
  36         suffix : typing.Optional[typing.Text] = ...,
  37         ) -> None: ...
  38     def HasField(self, field_name: typing_extensions.Literal["major",b"major","minor",b"minor","patch",b"patch","suffix",b"suffix"]) -> builtins.bool: ...
  39     def ClearField(self, field_name: typing_extensions.Literal["major",b"major","minor",b"minor","patch",b"patch","suffix",b"suffix"]) -> None: ...
  40 global___Version = Version
  41
  42 class CodeGeneratorRequest(google.protobuf.message.Message):
  43     """An encoded CodeGeneratorRequest is written to the plugin's stdin."""
  44     DESCRIPTOR: google.protobuf.descriptor.Descriptor = ...
  45     FILE_TO_GENERATE_FIELD_NUMBER: builtins.int
  46     PARAMETER_FIELD_NUMBER: builtins.int
  47     PROTO_FILE_FIELD_NUMBER: builtins.int
  48     COMPILER_VERSION_FIELD_NUMBER: builtins.int
  49     @property
  50     def file_to_generate(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[typing.Text]:
  51         """The .proto files that were explicitly listed on the command-line.  The
  52         code generator should generate code only for these files.  Each file's
  53         descriptor will be included in proto_file, below.
  54         """
  55         pass
  56     parameter: typing.Text = ...
  57     """The generator parameter passed on the command-line."""
  58
  59     @property
  60     def proto_file(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[google.protobuf.descriptor_pb2.FileDescriptorProto]:
  61         """FileDescriptorProtos for all files in files_to_generate and everything
  62         they import.  The files will appear in topological order, so each file
  63         appears before any file that imports it.
  64
  65         protoc guarantees that all proto_files will be written after
  66         the fields above, even though this is not technically guaranteed by the
  67         protobuf wire format.  This theoretically could allow a plugin to stream
  68         in the FileDescriptorProtos and handle them one by one rather than read
  69         the entire set into memory at once.  However, as of this writing, this
  70         is not similarly optimized on protoc's end -- it will store all fields in
  71         memory at once before sending them to the plugin.
  72
  73         Type names of fields and extensions in the FileDescriptorProto are always
  74         fully qualified.
  75         """
  76         pass
  77     @property
  78     def compiler_version(self) -> global___Version:
  79         """The version number of protocol compiler."""
  80         pass
  81     def __init__(self,
  82         *,
  83         file_to_generate : typing.Optional[typing.Iterable[typing.Text]] = ...,
  84         parameter : typing.Optional[typing.Text] = ...,
  85         proto_file : typing.Optional[typing.Iterable[google.protobuf.descriptor_pb2.FileDescriptorProto]] = ...,
  86         compiler_version : typing.Optional[global___Version] = ...,
  87         ) -> None: ...
  88     def HasField(self, field_name: typing_extensions.Literal["compiler_version",b"compiler_version","parameter",b"parameter"]) -> builtins.bool: ...
  89     def ClearField(self, field_name: typing_extensions.Literal["compiler_version",b"compiler_version","file_to_generate",b"file_to_generate","parameter",b"parameter","proto_file",b"proto_file"]) -> None: ...
  90 global___CodeGeneratorRequest = CodeGeneratorRequest
  91
  92 class CodeGeneratorResponse(google.protobuf.message.Message):
  93     """The plugin writes an encoded CodeGeneratorResponse to stdout."""
  94     DESCRIPTOR: google.protobuf.descriptor.Descriptor = ...
  95     class Feature(_Feature, metaclass=_FeatureEnumTypeWrapper):
  96         """Sync with code_generator.h."""
  97         pass
  98     class _Feature:
  99         V = typing.NewType('V', builtins.int)
 100     class _FeatureEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Feature.V], builtins.type):
 101         DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor = ...
 102         FEATURE_NONE = CodeGeneratorResponse.Feature.V(0)
 103         FEATURE_PROTO3_OPTIONAL = CodeGeneratorResponse.Feature.V(1)
 104
 105     FEATURE_NONE = CodeGeneratorResponse.Feature.V(0)
 106     FEATURE_PROTO3_OPTIONAL = CodeGeneratorResponse.Feature.V(1)
 107
 108     class File(google.protobuf.message.Message):
 109         """Represents a single generated file."""
 110         DESCRIPTOR: google.protobuf.descriptor.Descriptor = ...
 111         NAME_FIELD_NUMBER: builtins.int
 112         INSERTION_POINT_FIELD_NUMBER: builtins.int
 113         CONTENT_FIELD_NUMBER: builtins.int
 114         GENERATED_CODE_INFO_FIELD_NUMBER: builtins.int
 115         name: typing.Text = ...
 116         """The file name, relative to the output directory.  The name must not
 117         contain "." or ".." components and must be relative, not be absolute (so,
 118         the file cannot lie outside the output directory).  "/" must be used as
 119         the path separator, not "\\".
 120
 121         If the name is omitted, the content will be appended to the previous
 122         file.  This allows the generator to break large files into small chunks,
 123         and allows the generated text to be streamed back to protoc so that large
 124         files need not reside completely in memory at one time.  Note that as of
 125         this writing protoc does not optimize for this -- it will read the entire
 126         CodeGeneratorResponse before writing files to disk.
 127         """
 128
 129         insertion_point: typing.Text = ...
 130         """If non-empty, indicates that the named file should already exist, and the
 131         content here is to be inserted into that file at a defined insertion
 132         point.  This feature allows a code generator to extend the output
 133         produced by another code generator.  The original generator may provide
 134         insertion points by placing special annotations in the file that look
 135         like:
 136           @@protoc_insertion_point(NAME)
 137         The annotation can have arbitrary text before and after it on the line,
 138         which allows it to be placed in a comment.  NAME should be replaced with
 139         an identifier naming the point -- this is what other generators will use
 140         as the insertion_point.  Code inserted at this point will be placed
 141         immediately above the line containing the insertion point (thus multiple
 142         insertions to the same point will come out in the order they were added).
 143         The double-@ is intended to make it unlikely that the generated code
 144         could contain things that look like insertion points by accident.
 145
 146         For example, the C++ code generator places the following line in the
 147         .pb.h files that it generates:
 148           // @@protoc_insertion_point(namespace_scope)
 149         This line appears within the scope of the file's package namespace, but
 150         outside of any particular class.  Another plugin can then specify the
 151         insertion_point "namespace_scope" to generate additional classes or
 152         other declarations that should be placed in this scope.
 153
 154         Note that if the line containing the insertion point begins with
 155         whitespace, the same whitespace will be added to every line of the
 156         inserted text.  This is useful for languages like Python, where
 157         indentation matters.  In these languages, the insertion point comment
 158         should be indented the same amount as any inserted code will need to be
 159         in order to work correctly in that context.
 160
 161         The code generator that generates the initial file and the one which
 162         inserts into it must both run as part of a single invocation of protoc.
 163         Code generators are executed in the order in which they appear on the
 164         command line.
 165
 166         If |insertion_point| is present, |name| must also be present.
 167         """
 168
 169         content: typing.Text = ...
 170         """The file contents."""
 171
 172         @property
 173         def generated_code_info(self) -> google.protobuf.descriptor_pb2.GeneratedCodeInfo:
 174             """Information describing the file content being inserted. If an insertion
 175             point is used, this information will be appropriately offset and inserted
 176             into the code generation metadata for the generated files.
 177             """
 178             pass
 179         def __init__(self,
 180             *,
 181             name : typing.Optional[typing.Text] = ...,
 182             insertion_point : typing.Optional[typing.Text] = ...,
 183             content : typing.Optional[typing.Text] = ...,
 184             generated_code_info : typing.Optional[google.protobuf.descriptor_pb2.GeneratedCodeInfo] = ...,
 185             ) -> None: ...
 186         def HasField(self, field_name: typing_extensions.Literal["content",b"content","generated_code_info",b"generated_code_info","insertion_point",b"insertion_point","name",b"name"]) -> builtins.bool: ...
 187         def ClearField(self, field_name: typing_extensions.Literal["content",b"content","generated_code_info",b"generated_code_info","insertion_point",b"insertion_point","name",b"name"]) -> None: ...
 188
 189     ERROR_FIELD_NUMBER: builtins.int
 190     SUPPORTED_FEATURES_FIELD_NUMBER: builtins.int
 191     FILE_FIELD_NUMBER: builtins.int
 192     error: typing.Text = ...
 193     """Error message.  If non-empty, code generation failed.  The plugin process
 194     should exit with status code zero even if it reports an error in this way.
 195
 196     This should be used to indicate errors in .proto files which prevent the
 197     code generator from generating correct code.  Errors which indicate a
 198     problem in protoc itself -- such as the input CodeGeneratorRequest being
 199     unparseable -- should be reported by writing a message to stderr and
 200     exiting with a non-zero status code.
 201     """
 202
 203     supported_features: builtins.int = ...
 204     """A bitmask of supported features that the code generator supports.
 205     This is a bitwise "or" of values from the Feature enum.
 206     """
 207
 208     @property
 209     def file(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___CodeGeneratorResponse.File]: ...
 210     def __init__(self,
 211         *,
 212         error : typing.Optional[typing.Text] = ...,
 213         supported_features : typing.Optional[builtins.int] = ...,
 214         file : typing.Optional[typing.Iterable[global___CodeGeneratorResponse.File]] = ...,
 215         ) -> None: ...
 216     def HasField(self, field_name: typing_extensions.Literal["error",b"error","supported_features",b"supported_features"]) -> builtins.bool: ...
 217     def ClearField(self, field_name: typing_extensions.Literal["error",b"error","file",b"file","supported_features",b"supported_features"]) -> None: ...
 218 global___CodeGeneratorResponse = CodeGeneratorResponse