src/resultstore.pb.h

// This file is auto-generated by generate_proto_header.py, do not edit

// clang-format off

#ifndef NINJA_RESULTSTORE_PB_H
#define NINJA_RESULTSTORE_PB_H

#include <inttypes.h>

#include <string>
#include <vector>

struct OutputStream;

namespace rs {
namespace google {
namespace api {
struct Http;
struct HttpRule;
struct CustomHttpPattern;
}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
struct FileDescriptorSet;
struct FileDescriptorProto;
struct DescriptorProto;
struct ExtensionRangeOptions;
struct FieldDescriptorProto;
struct OneofDescriptorProto;
struct EnumDescriptorProto;
struct EnumValueDescriptorProto;
struct ServiceDescriptorProto;
struct MethodDescriptorProto;
struct FileOptions;
struct MessageOptions;
struct FieldOptions;
struct OneofOptions;
struct EnumOptions;
struct EnumValueOptions;
struct ServiceOptions;
struct MethodOptions;
struct UninterpretedOption;
struct FeatureSet;
struct FeatureSetDefaults;
struct SourceCodeInfo;
struct GeneratedCodeInfo;
}  // namespace protobuf
}  // namespace google
namespace google {
namespace api {
}  // namespace api
}  // namespace google
namespace google {
namespace api {
}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
struct Duration;
}  // namespace protobuf
}  // namespace google
namespace google {
namespace api {
struct CommonLanguageSettings;
struct ClientLibrarySettings;
struct Publishing;
struct JavaSettings;
struct CppSettings;
struct PhpSettings;
struct PythonSettings;
struct NodeSettings;
struct DotnetSettings;
struct RubySettings;
struct GoSettings;
struct MethodSettings;
struct SelectiveGapicGeneration;
}  // namespace api
}  // namespace google
namespace google {
namespace api {
}  // namespace api
}  // namespace google
namespace google {
namespace api {
struct ResourceDescriptor;
struct ResourceReference;
}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
struct Timestamp;
}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct StatusAttributes;
struct Property;
struct Timing;
struct Dependency;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct LineCoverage;
struct BranchCoverage;
struct FileCoverage;
struct ActionCoverage;
struct AggregateCoverage;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace protobuf {
struct DoubleValue;
struct FloatValue;
struct Int64Value;
struct UInt64Value;
struct Int32Value;
struct UInt32Value;
struct BoolValue;
struct StringValue;
struct BytesValue;
}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct File;
struct ArchiveEntry;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct FileProcessingErrors;
struct FileProcessingError;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct TestSuite;
struct Test;
struct TestCase;
struct TestFailure;
struct TestError;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct Action;
struct BuildAction;
struct TestAction;
struct ActionAttributes;
struct InputFileInfo;
struct LocalTestTiming;
struct RemoteTestAttemptTiming;
struct RemoteTestTiming;
struct TestTiming;
struct TestWarning;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct Configuration;
struct ConfigurationAttributes;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct ConfiguredTarget;
struct ConfiguredTestAttributes;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct FileSet;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct LineCoverageSummary;
struct BranchCoverageSummary;
struct LanguageCoverageSummary;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct Invocation;
struct WorkspaceContext;
struct WorkspaceInfo;
struct CommandLine;
struct InvocationAttributes;
struct InvocationContext;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct Target;
struct TargetAttributes;
struct TestAttributes;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct UploadMetadata;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace protobuf {
struct Empty;
}  // namespace protobuf
}  // namespace google
namespace google {
namespace protobuf {
struct FieldMask;
}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct CreateInvocationRequest;
struct UpdateInvocationRequest;
struct MergeInvocationRequest;
struct TouchInvocationRequest;
struct TouchInvocationResponse;
struct DeleteInvocationRequest;
struct FinalizeInvocationRequest;
struct FinalizeInvocationResponse;
struct CreateTargetRequest;
struct UpdateTargetRequest;
struct MergeTargetRequest;
struct FinalizeTargetRequest;
struct FinalizeTargetResponse;
struct CreateConfiguredTargetRequest;
struct UpdateConfiguredTargetRequest;
struct MergeConfiguredTargetRequest;
struct FinalizeConfiguredTargetRequest;
struct FinalizeConfiguredTargetResponse;
struct CreateActionRequest;
struct UpdateActionRequest;
struct MergeActionRequest;
struct CreateConfigurationRequest;
struct UpdateConfigurationRequest;
struct CreateFileSetRequest;
struct UpdateFileSetRequest;
struct MergeFileSetRequest;
struct UploadBatchRequest;
struct UploadBatchResponse;
struct UploadRequest;
struct GetInvocationUploadMetadataRequest;
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google

namespace google {
namespace api {
struct Http {
  std::vector< ::rs::google::api::HttpRule > rules_;
  bool has_rules_ = false;
  bool fully_decode_reserved_expansion_ = false;
  bool has_fully_decode_reserved_expansion_ = false;

  Http() = default;
  Http(const Http&) = default;
  Http(Http&&) = default;
  Http& operator=(const Http&) = default;
  Http& operator=(Http&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::api::HttpRule >* mutable_rules() {
    has_rules_ = true;
    return &rules_;
  }
  void add_rules(const ::rs::google::api::HttpRule& value);
  bool* mutable_fully_decode_reserved_expansion() {
    has_fully_decode_reserved_expansion_ = true;
    return &fully_decode_reserved_expansion_;
  }
  void set_fully_decode_reserved_expansion(const bool& value);
};  // struct Http
struct CustomHttpPattern {
  std::string kind_;
  bool has_kind_ = false;
  std::string path_;
  bool has_path_ = false;

  CustomHttpPattern() = default;
  CustomHttpPattern(const CustomHttpPattern&) = default;
  CustomHttpPattern(CustomHttpPattern&&) = default;
  CustomHttpPattern& operator=(const CustomHttpPattern&) = default;
  CustomHttpPattern& operator=(CustomHttpPattern&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_kind() {
    has_kind_ = true;
    return &kind_;
  }
  void set_kind(const std::string& value);
  std::string* mutable_path() {
    has_path_ = true;
    return &path_;
  }
  void set_path(const std::string& value);
};  // struct CustomHttpPattern
struct HttpRule {
  std::string selector_;
  bool has_selector_ = false;
  std::string get_;
  bool has_get_ = false;
  std::string put_;
  bool has_put_ = false;
  std::string post_;
  bool has_post_ = false;
  std::string delete_;
  bool has_delete_ = false;
  std::string patch_;
  bool has_patch_ = false;
  ::rs::google::api::CustomHttpPattern custom_;
  bool has_custom_ = false;
  std::string body_;
  bool has_body_ = false;
  std::string response_body_;
  bool has_response_body_ = false;
  std::vector< ::rs::google::api::HttpRule > additional_bindings_;
  bool has_additional_bindings_ = false;

  HttpRule() = default;
  HttpRule(const HttpRule&) = default;
  HttpRule(HttpRule&&) = default;
  HttpRule& operator=(const HttpRule&) = default;
  HttpRule& operator=(HttpRule&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_selector() {
    has_selector_ = true;
    return &selector_;
  }
  void set_selector(const std::string& value);
  std::string* mutable_get() {
    has_get_ = true;
    return &get_;
  }
  void set_get(const std::string& value);
  std::string* mutable_put() {
    has_put_ = true;
    return &put_;
  }
  void set_put(const std::string& value);
  std::string* mutable_post() {
    has_post_ = true;
    return &post_;
  }
  void set_post(const std::string& value);
  std::string* mutable_delete() {
    has_delete_ = true;
    return &delete_;
  }
  void set_delete(const std::string& value);
  std::string* mutable_patch() {
    has_patch_ = true;
    return &patch_;
  }
  void set_patch(const std::string& value);
  ::rs::google::api::CustomHttpPattern* mutable_custom() {
    has_custom_ = true;
    return &custom_;
  }
  std::string* mutable_body() {
    has_body_ = true;
    return &body_;
  }
  void set_body(const std::string& value);
  std::string* mutable_response_body() {
    has_response_body_ = true;
    return &response_body_;
  }
  void set_response_body(const std::string& value);
  std::vector< ::rs::google::api::HttpRule >* mutable_additional_bindings() {
    has_additional_bindings_ = true;
    return &additional_bindings_;
  }
  void add_additional_bindings(const ::rs::google::api::HttpRule& value);
};  // struct HttpRule
}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
enum Edition {
  EDITION_UNKNOWN = 0,
  EDITION_LEGACY = 900,
  EDITION_PROTO2 = 998,
  EDITION_PROTO3 = 999,
  EDITION_2023 = 1000,
  EDITION_2024 = 1001,
  EDITION_1_TEST_ONLY = 1,
  EDITION_2_TEST_ONLY = 2,
  EDITION_99997_TEST_ONLY = 99997,
  EDITION_99998_TEST_ONLY = 99998,
  EDITION_99999_TEST_ONLY = 99999,
  EDITION_MAX = 2147483647,
};

struct FileDescriptorSet {
  std::vector< ::rs::google::protobuf::FileDescriptorProto > file_;
  bool has_file_ = false;

  FileDescriptorSet() = default;
  FileDescriptorSet(const FileDescriptorSet&) = default;
  FileDescriptorSet(FileDescriptorSet&&) = default;
  FileDescriptorSet& operator=(const FileDescriptorSet&) = default;
  FileDescriptorSet& operator=(FileDescriptorSet&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::protobuf::FileDescriptorProto >* mutable_file() {
    has_file_ = true;
    return &file_;
  }
  void add_file(const ::rs::google::protobuf::FileDescriptorProto& value);
};  // struct FileDescriptorSet
struct FeatureSet {
  enum FieldPresence {
    FIELD_PRESENCE_UNKNOWN = 0,
    EXPLICIT = 1,
    IMPLICIT = 2,
    LEGACY_REQUIRED = 3,
  };

  enum EnumType {
    ENUM_TYPE_UNKNOWN = 0,
    OPEN = 1,
    CLOSED = 2,
  };

  enum RepeatedFieldEncoding {
    REPEATED_FIELD_ENCODING_UNKNOWN = 0,
    PACKED = 1,
    EXPANDED = 2,
  };

  enum Utf8Validation {
    UTF8_VALIDATION_UNKNOWN = 0,
    VERIFY = 2,
    NONE = 3,
  };

  enum MessageEncoding {
    MESSAGE_ENCODING_UNKNOWN = 0,
    LENGTH_PREFIXED = 1,
    DELIMITED = 2,
  };

  enum JsonFormat {
    JSON_FORMAT_UNKNOWN = 0,
    ALLOW = 1,
    LEGACY_BEST_EFFORT = 2,
  };

  ::rs::google::protobuf::FeatureSet::FieldPresence field_presence_ = static_cast< ::rs::google::protobuf::FeatureSet::FieldPresence >(0);
  bool has_field_presence_ = false;
  ::rs::google::protobuf::FeatureSet::EnumType enum_type_ = static_cast< ::rs::google::protobuf::FeatureSet::EnumType >(0);
  bool has_enum_type_ = false;
  ::rs::google::protobuf::FeatureSet::RepeatedFieldEncoding repeated_field_encoding_ = static_cast< ::rs::google::protobuf::FeatureSet::RepeatedFieldEncoding >(0);
  bool has_repeated_field_encoding_ = false;
  ::rs::google::protobuf::FeatureSet::Utf8Validation utf8_validation_ = static_cast< ::rs::google::protobuf::FeatureSet::Utf8Validation >(0);
  bool has_utf8_validation_ = false;
  ::rs::google::protobuf::FeatureSet::MessageEncoding message_encoding_ = static_cast< ::rs::google::protobuf::FeatureSet::MessageEncoding >(0);
  bool has_message_encoding_ = false;
  ::rs::google::protobuf::FeatureSet::JsonFormat json_format_ = static_cast< ::rs::google::protobuf::FeatureSet::JsonFormat >(0);
  bool has_json_format_ = false;

  FeatureSet() = default;
  FeatureSet(const FeatureSet&) = default;
  FeatureSet(FeatureSet&&) = default;
  FeatureSet& operator=(const FeatureSet&) = default;
  FeatureSet& operator=(FeatureSet&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::protobuf::FeatureSet::FieldPresence* mutable_field_presence() {
    has_field_presence_ = true;
    return &field_presence_;
  }
  void set_field_presence(const ::rs::google::protobuf::FeatureSet::FieldPresence& value);
  ::rs::google::protobuf::FeatureSet::EnumType* mutable_enum_type() {
    has_enum_type_ = true;
    return &enum_type_;
  }
  void set_enum_type(const ::rs::google::protobuf::FeatureSet::EnumType& value);
  ::rs::google::protobuf::FeatureSet::RepeatedFieldEncoding* mutable_repeated_field_encoding() {
    has_repeated_field_encoding_ = true;
    return &repeated_field_encoding_;
  }
  void set_repeated_field_encoding(const ::rs::google::protobuf::FeatureSet::RepeatedFieldEncoding& value);
  ::rs::google::protobuf::FeatureSet::Utf8Validation* mutable_utf8_validation() {
    has_utf8_validation_ = true;
    return &utf8_validation_;
  }
  void set_utf8_validation(const ::rs::google::protobuf::FeatureSet::Utf8Validation& value);
  ::rs::google::protobuf::FeatureSet::MessageEncoding* mutable_message_encoding() {
    has_message_encoding_ = true;
    return &message_encoding_;
  }
  void set_message_encoding(const ::rs::google::protobuf::FeatureSet::MessageEncoding& value);
  ::rs::google::protobuf::FeatureSet::JsonFormat* mutable_json_format() {
    has_json_format_ = true;
    return &json_format_;
  }
  void set_json_format(const ::rs::google::protobuf::FeatureSet::JsonFormat& value);
};  // struct FeatureSet
struct FileOptions {
  enum OptimizeMode {
    SPEED = 1,
    CODE_SIZE = 2,
    LITE_RUNTIME = 3,
  };

  std::string java_package_;
  bool has_java_package_ = false;
  std::string java_outer_classname_;
  bool has_java_outer_classname_ = false;
  bool java_multiple_files_ = false;
  bool has_java_multiple_files_ = false;
  bool java_generate_equals_and_hash_ = false;
  bool has_java_generate_equals_and_hash_ = false;
  bool java_string_check_utf8_ = false;
  bool has_java_string_check_utf8_ = false;
  ::rs::google::protobuf::FileOptions::OptimizeMode optimize_for_ = static_cast< ::rs::google::protobuf::FileOptions::OptimizeMode >(0);
  bool has_optimize_for_ = false;
  std::string go_package_;
  bool has_go_package_ = false;
  bool cc_generic_services_ = false;
  bool has_cc_generic_services_ = false;
  bool java_generic_services_ = false;
  bool has_java_generic_services_ = false;
  bool py_generic_services_ = false;
  bool has_py_generic_services_ = false;
  bool deprecated_ = false;
  bool has_deprecated_ = false;
  bool cc_enable_arenas_ = false;
  bool has_cc_enable_arenas_ = false;
  std::string objc_class_prefix_;
  bool has_objc_class_prefix_ = false;
  std::string csharp_namespace_;
  bool has_csharp_namespace_ = false;
  std::string swift_prefix_;
  bool has_swift_prefix_ = false;
  std::string php_class_prefix_;
  bool has_php_class_prefix_ = false;
  std::string php_namespace_;
  bool has_php_namespace_ = false;
  std::string php_metadata_namespace_;
  bool has_php_metadata_namespace_ = false;
  std::string ruby_package_;
  bool has_ruby_package_ = false;
  ::rs::google::protobuf::FeatureSet features_;
  bool has_features_ = false;
  std::vector< ::rs::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_ = false;

  FileOptions() = default;
  FileOptions(const FileOptions&) = default;
  FileOptions(FileOptions&&) = default;
  FileOptions& operator=(const FileOptions&) = default;
  FileOptions& operator=(FileOptions&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_java_package() {
    has_java_package_ = true;
    return &java_package_;
  }
  void set_java_package(const std::string& value);
  std::string* mutable_java_outer_classname() {
    has_java_outer_classname_ = true;
    return &java_outer_classname_;
  }
  void set_java_outer_classname(const std::string& value);
  bool* mutable_java_multiple_files() {
    has_java_multiple_files_ = true;
    return &java_multiple_files_;
  }
  void set_java_multiple_files(const bool& value);
  bool* mutable_java_generate_equals_and_hash() {
    has_java_generate_equals_and_hash_ = true;
    return &java_generate_equals_and_hash_;
  }
  void set_java_generate_equals_and_hash(const bool& value);
  bool* mutable_java_string_check_utf8() {
    has_java_string_check_utf8_ = true;
    return &java_string_check_utf8_;
  }
  void set_java_string_check_utf8(const bool& value);
  ::rs::google::protobuf::FileOptions::OptimizeMode* mutable_optimize_for() {
    has_optimize_for_ = true;
    return &optimize_for_;
  }
  void set_optimize_for(const ::rs::google::protobuf::FileOptions::OptimizeMode& value);
  std::string* mutable_go_package() {
    has_go_package_ = true;
    return &go_package_;
  }
  void set_go_package(const std::string& value);
  bool* mutable_cc_generic_services() {
    has_cc_generic_services_ = true;
    return &cc_generic_services_;
  }
  void set_cc_generic_services(const bool& value);
  bool* mutable_java_generic_services() {
    has_java_generic_services_ = true;
    return &java_generic_services_;
  }
  void set_java_generic_services(const bool& value);
  bool* mutable_py_generic_services() {
    has_py_generic_services_ = true;
    return &py_generic_services_;
  }
  void set_py_generic_services(const bool& value);
  bool* mutable_deprecated() {
    has_deprecated_ = true;
    return &deprecated_;
  }
  void set_deprecated(const bool& value);
  bool* mutable_cc_enable_arenas() {
    has_cc_enable_arenas_ = true;
    return &cc_enable_arenas_;
  }
  void set_cc_enable_arenas(const bool& value);
  std::string* mutable_objc_class_prefix() {
    has_objc_class_prefix_ = true;
    return &objc_class_prefix_;
  }
  void set_objc_class_prefix(const std::string& value);
  std::string* mutable_csharp_namespace() {
    has_csharp_namespace_ = true;
    return &csharp_namespace_;
  }
  void set_csharp_namespace(const std::string& value);
  std::string* mutable_swift_prefix() {
    has_swift_prefix_ = true;
    return &swift_prefix_;
  }
  void set_swift_prefix(const std::string& value);
  std::string* mutable_php_class_prefix() {
    has_php_class_prefix_ = true;
    return &php_class_prefix_;
  }
  void set_php_class_prefix(const std::string& value);
  std::string* mutable_php_namespace() {
    has_php_namespace_ = true;
    return &php_namespace_;
  }
  void set_php_namespace(const std::string& value);
  std::string* mutable_php_metadata_namespace() {
    has_php_metadata_namespace_ = true;
    return &php_metadata_namespace_;
  }
  void set_php_metadata_namespace(const std::string& value);
  std::string* mutable_ruby_package() {
    has_ruby_package_ = true;
    return &ruby_package_;
  }
  void set_ruby_package(const std::string& value);
  ::rs::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  std::vector< ::rs::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::rs::google::protobuf::UninterpretedOption& value);
};  // struct FileOptions
struct SourceCodeInfo {
  struct Location {
    std::vector< int32_t > path_;
    bool has_path_ = false;
    std::vector< int32_t > span_;
    bool has_span_ = false;
    std::string leading_comments_;
    bool has_leading_comments_ = false;
    std::string trailing_comments_;
    bool has_trailing_comments_ = false;
    std::vector< std::string > leading_detached_comments_;
    bool has_leading_detached_comments_ = false;

    Location() = default;
    Location(const Location&) = default;
    Location(Location&&) = default;
    Location& operator=(const Location&) = default;
    Location& operator=(Location&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::vector< int32_t >* mutable_path() {
      has_path_ = true;
      return &path_;
    }
    void add_path(const int32_t& value);
    void set_path(const std::vector< int32_t >& value);
    std::vector< int32_t >* mutable_span() {
      has_span_ = true;
      return &span_;
    }
    void add_span(const int32_t& value);
    void set_span(const std::vector< int32_t >& value);
    std::string* mutable_leading_comments() {
      has_leading_comments_ = true;
      return &leading_comments_;
    }
    void set_leading_comments(const std::string& value);
    std::string* mutable_trailing_comments() {
      has_trailing_comments_ = true;
      return &trailing_comments_;
    }
    void set_trailing_comments(const std::string& value);
    std::vector< std::string >* mutable_leading_detached_comments() {
      has_leading_detached_comments_ = true;
      return &leading_detached_comments_;
    }
    void add_leading_detached_comments(const std::string& value);
    void set_leading_detached_comments(const std::vector< std::string >& value);
  };  // struct Location
  std::vector< ::rs::google::protobuf::SourceCodeInfo::Location > location_;
  bool has_location_ = false;

  SourceCodeInfo() = default;
  SourceCodeInfo(const SourceCodeInfo&) = default;
  SourceCodeInfo(SourceCodeInfo&&) = default;
  SourceCodeInfo& operator=(const SourceCodeInfo&) = default;
  SourceCodeInfo& operator=(SourceCodeInfo&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::protobuf::SourceCodeInfo::Location >* mutable_location() {
    has_location_ = true;
    return &location_;
  }
  void add_location(const ::rs::google::protobuf::SourceCodeInfo::Location& value);
};  // struct SourceCodeInfo
struct FileDescriptorProto {
  std::string name_;
  bool has_name_ = false;
  std::string package_;
  bool has_package_ = false;
  std::vector< std::string > dependency_;
  bool has_dependency_ = false;
  std::vector< int32_t > public_dependency_;
  bool has_public_dependency_ = false;
  std::vector< int32_t > weak_dependency_;
  bool has_weak_dependency_ = false;
  std::vector< ::rs::google::protobuf::DescriptorProto > message_type_;
  bool has_message_type_ = false;
  std::vector< ::rs::google::protobuf::EnumDescriptorProto > enum_type_;
  bool has_enum_type_ = false;
  std::vector< ::rs::google::protobuf::ServiceDescriptorProto > service_;
  bool has_service_ = false;
  std::vector< ::rs::google::protobuf::FieldDescriptorProto > extension_;
  bool has_extension_ = false;
  ::rs::google::protobuf::FileOptions options_;
  bool has_options_ = false;
  ::rs::google::protobuf::SourceCodeInfo source_code_info_;
  bool has_source_code_info_ = false;
  std::string syntax_;
  bool has_syntax_ = false;
  ::rs::google::protobuf::Edition edition_ = static_cast< ::rs::google::protobuf::Edition >(0);
  bool has_edition_ = false;

  FileDescriptorProto() = default;
  FileDescriptorProto(const FileDescriptorProto&) = default;
  FileDescriptorProto(FileDescriptorProto&&) = default;
  FileDescriptorProto& operator=(const FileDescriptorProto&) = default;
  FileDescriptorProto& operator=(FileDescriptorProto&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::string* mutable_package() {
    has_package_ = true;
    return &package_;
  }
  void set_package(const std::string& value);
  std::vector< std::string >* mutable_dependency() {
    has_dependency_ = true;
    return &dependency_;
  }
  void add_dependency(const std::string& value);
  void set_dependency(const std::vector< std::string >& value);
  std::vector< int32_t >* mutable_public_dependency() {
    has_public_dependency_ = true;
    return &public_dependency_;
  }
  void add_public_dependency(const int32_t& value);
  void set_public_dependency(const std::vector< int32_t >& value);
  std::vector< int32_t >* mutable_weak_dependency() {
    has_weak_dependency_ = true;
    return &weak_dependency_;
  }
  void add_weak_dependency(const int32_t& value);
  void set_weak_dependency(const std::vector< int32_t >& value);
  std::vector< ::rs::google::protobuf::DescriptorProto >* mutable_message_type() {
    has_message_type_ = true;
    return &message_type_;
  }
  void add_message_type(const ::rs::google::protobuf::DescriptorProto& value);
  std::vector< ::rs::google::protobuf::EnumDescriptorProto >* mutable_enum_type() {
    has_enum_type_ = true;
    return &enum_type_;
  }
  void add_enum_type(const ::rs::google::protobuf::EnumDescriptorProto& value);
  std::vector< ::rs::google::protobuf::ServiceDescriptorProto >* mutable_service() {
    has_service_ = true;
    return &service_;
  }
  void add_service(const ::rs::google::protobuf::ServiceDescriptorProto& value);
  std::vector< ::rs::google::protobuf::FieldDescriptorProto >* mutable_extension() {
    has_extension_ = true;
    return &extension_;
  }
  void add_extension(const ::rs::google::protobuf::FieldDescriptorProto& value);
  ::rs::google::protobuf::FileOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
  ::rs::google::protobuf::SourceCodeInfo* mutable_source_code_info() {
    has_source_code_info_ = true;
    return &source_code_info_;
  }
  std::string* mutable_syntax() {
    has_syntax_ = true;
    return &syntax_;
  }
  void set_syntax(const std::string& value);
  ::rs::google::protobuf::Edition* mutable_edition() {
    has_edition_ = true;
    return &edition_;
  }
  void set_edition(const ::rs::google::protobuf::Edition& value);
};  // struct FileDescriptorProto
struct ExtensionRangeOptions {
  enum VerificationState {
    DECLARATION = 0,
    UNVERIFIED = 1,
  };

  struct Declaration {
    int32_t number_ = static_cast< int32_t >(0);
    bool has_number_ = false;
    std::string full_name_;
    bool has_full_name_ = false;
    std::string type_;
    bool has_type_ = false;
    bool reserved_ = false;
    bool has_reserved_ = false;
    bool repeated_ = false;
    bool has_repeated_ = false;

    Declaration() = default;
    Declaration(const Declaration&) = default;
    Declaration(Declaration&&) = default;
    Declaration& operator=(const Declaration&) = default;
    Declaration& operator=(Declaration&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int32_t* mutable_number() {
      has_number_ = true;
      return &number_;
    }
    void set_number(const int32_t& value);
    std::string* mutable_full_name() {
      has_full_name_ = true;
      return &full_name_;
    }
    void set_full_name(const std::string& value);
    std::string* mutable_type() {
      has_type_ = true;
      return &type_;
    }
    void set_type(const std::string& value);
    bool* mutable_reserved() {
      has_reserved_ = true;
      return &reserved_;
    }
    void set_reserved(const bool& value);
    bool* mutable_repeated() {
      has_repeated_ = true;
      return &repeated_;
    }
    void set_repeated(const bool& value);
  };  // struct Declaration
  std::vector< ::rs::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_ = false;
  std::vector< ::rs::google::protobuf::ExtensionRangeOptions::Declaration > declaration_;
  bool has_declaration_ = false;
  ::rs::google::protobuf::FeatureSet features_;
  bool has_features_ = false;
  ::rs::google::protobuf::ExtensionRangeOptions::VerificationState verification_ = static_cast< ::rs::google::protobuf::ExtensionRangeOptions::VerificationState >(0);
  bool has_verification_ = false;

  ExtensionRangeOptions() = default;
  ExtensionRangeOptions(const ExtensionRangeOptions&) = default;
  ExtensionRangeOptions(ExtensionRangeOptions&&) = default;
  ExtensionRangeOptions& operator=(const ExtensionRangeOptions&) = default;
  ExtensionRangeOptions& operator=(ExtensionRangeOptions&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::rs::google::protobuf::UninterpretedOption& value);
  std::vector< ::rs::google::protobuf::ExtensionRangeOptions::Declaration >* mutable_declaration() {
    has_declaration_ = true;
    return &declaration_;
  }
  void add_declaration(const ::rs::google::protobuf::ExtensionRangeOptions::Declaration& value);
  ::rs::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  ::rs::google::protobuf::ExtensionRangeOptions::VerificationState* mutable_verification() {
    has_verification_ = true;
    return &verification_;
  }
  void set_verification(const ::rs::google::protobuf::ExtensionRangeOptions::VerificationState& value);
};  // struct ExtensionRangeOptions
struct MessageOptions {
  bool message_set_wire_format_ = false;
  bool has_message_set_wire_format_ = false;
  bool no_standard_descriptor_accessor_ = false;
  bool has_no_standard_descriptor_accessor_ = false;
  bool deprecated_ = false;
  bool has_deprecated_ = false;
  bool map_entry_ = false;
  bool has_map_entry_ = false;
  bool deprecated_legacy_json_field_conflicts_ = false;
  bool has_deprecated_legacy_json_field_conflicts_ = false;
  ::rs::google::protobuf::FeatureSet features_;
  bool has_features_ = false;
  std::vector< ::rs::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_ = false;

  MessageOptions() = default;
  MessageOptions(const MessageOptions&) = default;
  MessageOptions(MessageOptions&&) = default;
  MessageOptions& operator=(const MessageOptions&) = default;
  MessageOptions& operator=(MessageOptions&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_message_set_wire_format() {
    has_message_set_wire_format_ = true;
    return &message_set_wire_format_;
  }
  void set_message_set_wire_format(const bool& value);
  bool* mutable_no_standard_descriptor_accessor() {
    has_no_standard_descriptor_accessor_ = true;
    return &no_standard_descriptor_accessor_;
  }
  void set_no_standard_descriptor_accessor(const bool& value);
  bool* mutable_deprecated() {
    has_deprecated_ = true;
    return &deprecated_;
  }
  void set_deprecated(const bool& value);
  bool* mutable_map_entry() {
    has_map_entry_ = true;
    return &map_entry_;
  }
  void set_map_entry(const bool& value);
  bool* mutable_deprecated_legacy_json_field_conflicts() {
    has_deprecated_legacy_json_field_conflicts_ = true;
    return &deprecated_legacy_json_field_conflicts_;
  }
  void set_deprecated_legacy_json_field_conflicts(const bool& value);
  ::rs::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  std::vector< ::rs::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::rs::google::protobuf::UninterpretedOption& value);
};  // struct MessageOptions
struct DescriptorProto {
  struct ExtensionRange {
    int32_t start_ = static_cast< int32_t >(0);
    bool has_start_ = false;
    int32_t end_ = static_cast< int32_t >(0);
    bool has_end_ = false;
    ::rs::google::protobuf::ExtensionRangeOptions options_;
    bool has_options_ = false;

    ExtensionRange() = default;
    ExtensionRange(const ExtensionRange&) = default;
    ExtensionRange(ExtensionRange&&) = default;
    ExtensionRange& operator=(const ExtensionRange&) = default;
    ExtensionRange& operator=(ExtensionRange&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int32_t* mutable_start() {
      has_start_ = true;
      return &start_;
    }
    void set_start(const int32_t& value);
    int32_t* mutable_end() {
      has_end_ = true;
      return &end_;
    }
    void set_end(const int32_t& value);
    ::rs::google::protobuf::ExtensionRangeOptions* mutable_options() {
      has_options_ = true;
      return &options_;
    }
  };  // struct ExtensionRange
  struct ReservedRange {
    int32_t start_ = static_cast< int32_t >(0);
    bool has_start_ = false;
    int32_t end_ = static_cast< int32_t >(0);
    bool has_end_ = false;

    ReservedRange() = default;
    ReservedRange(const ReservedRange&) = default;
    ReservedRange(ReservedRange&&) = default;
    ReservedRange& operator=(const ReservedRange&) = default;
    ReservedRange& operator=(ReservedRange&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int32_t* mutable_start() {
      has_start_ = true;
      return &start_;
    }
    void set_start(const int32_t& value);
    int32_t* mutable_end() {
      has_end_ = true;
      return &end_;
    }
    void set_end(const int32_t& value);
  };  // struct ReservedRange
  std::string name_;
  bool has_name_ = false;
  std::vector< ::rs::google::protobuf::FieldDescriptorProto > field_;
  bool has_field_ = false;
  std::vector< ::rs::google::protobuf::FieldDescriptorProto > extension_;
  bool has_extension_ = false;
  std::vector< ::rs::google::protobuf::DescriptorProto > nested_type_;
  bool has_nested_type_ = false;
  std::vector< ::rs::google::protobuf::EnumDescriptorProto > enum_type_;
  bool has_enum_type_ = false;
  std::vector< ::rs::google::protobuf::DescriptorProto::ExtensionRange > extension_range_;
  bool has_extension_range_ = false;
  std::vector< ::rs::google::protobuf::OneofDescriptorProto > oneof_decl_;
  bool has_oneof_decl_ = false;
  ::rs::google::protobuf::MessageOptions options_;
  bool has_options_ = false;
  std::vector< ::rs::google::protobuf::DescriptorProto::ReservedRange > reserved_range_;
  bool has_reserved_range_ = false;
  std::vector< std::string > reserved_name_;
  bool has_reserved_name_ = false;

  DescriptorProto() = default;
  DescriptorProto(const DescriptorProto&) = default;
  DescriptorProto(DescriptorProto&&) = default;
  DescriptorProto& operator=(const DescriptorProto&) = default;
  DescriptorProto& operator=(DescriptorProto&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::vector< ::rs::google::protobuf::FieldDescriptorProto >* mutable_field() {
    has_field_ = true;
    return &field_;
  }
  void add_field(const ::rs::google::protobuf::FieldDescriptorProto& value);
  std::vector< ::rs::google::protobuf::FieldDescriptorProto >* mutable_extension() {
    has_extension_ = true;
    return &extension_;
  }
  void add_extension(const ::rs::google::protobuf::FieldDescriptorProto& value);
  std::vector< ::rs::google::protobuf::DescriptorProto >* mutable_nested_type() {
    has_nested_type_ = true;
    return &nested_type_;
  }
  void add_nested_type(const ::rs::google::protobuf::DescriptorProto& value);
  std::vector< ::rs::google::protobuf::EnumDescriptorProto >* mutable_enum_type() {
    has_enum_type_ = true;
    return &enum_type_;
  }
  void add_enum_type(const ::rs::google::protobuf::EnumDescriptorProto& value);
  std::vector< ::rs::google::protobuf::DescriptorProto::ExtensionRange >* mutable_extension_range() {
    has_extension_range_ = true;
    return &extension_range_;
  }
  void add_extension_range(const ::rs::google::protobuf::DescriptorProto::ExtensionRange& value);
  std::vector< ::rs::google::protobuf::OneofDescriptorProto >* mutable_oneof_decl() {
    has_oneof_decl_ = true;
    return &oneof_decl_;
  }
  void add_oneof_decl(const ::rs::google::protobuf::OneofDescriptorProto& value);
  ::rs::google::protobuf::MessageOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
  std::vector< ::rs::google::protobuf::DescriptorProto::ReservedRange >* mutable_reserved_range() {
    has_reserved_range_ = true;
    return &reserved_range_;
  }
  void add_reserved_range(const ::rs::google::protobuf::DescriptorProto::ReservedRange& value);
  std::vector< std::string >* mutable_reserved_name() {
    has_reserved_name_ = true;
    return &reserved_name_;
  }
  void add_reserved_name(const std::string& value);
  void set_reserved_name(const std::vector< std::string >& value);
};  // struct DescriptorProto
struct FieldOptions {
  enum CType {
    STRING = 0,
    CORD = 1,
    STRING_PIECE = 2,
  };

  enum JSType {
    JS_NORMAL = 0,
    JS_STRING = 1,
    JS_NUMBER = 2,
  };

  enum OptionRetention {
    RETENTION_UNKNOWN = 0,
    RETENTION_RUNTIME = 1,
    RETENTION_SOURCE = 2,
  };

  enum OptionTargetType {
    TARGET_TYPE_UNKNOWN = 0,
    TARGET_TYPE_FILE = 1,
    TARGET_TYPE_EXTENSION_RANGE = 2,
    TARGET_TYPE_MESSAGE = 3,
    TARGET_TYPE_FIELD = 4,
    TARGET_TYPE_ONEOF = 5,
    TARGET_TYPE_ENUM = 6,
    TARGET_TYPE_ENUM_ENTRY = 7,
    TARGET_TYPE_SERVICE = 8,
    TARGET_TYPE_METHOD = 9,
  };

  struct EditionDefault {
    ::rs::google::protobuf::Edition edition_ = static_cast< ::rs::google::protobuf::Edition >(0);
    bool has_edition_ = false;
    std::string value_;
    bool has_value_ = false;

    EditionDefault() = default;
    EditionDefault(const EditionDefault&) = default;
    EditionDefault(EditionDefault&&) = default;
    EditionDefault& operator=(const EditionDefault&) = default;
    EditionDefault& operator=(EditionDefault&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    ::rs::google::protobuf::Edition* mutable_edition() {
      has_edition_ = true;
      return &edition_;
    }
    void set_edition(const ::rs::google::protobuf::Edition& value);
    std::string* mutable_value() {
      has_value_ = true;
      return &value_;
    }
    void set_value(const std::string& value);
  };  // struct EditionDefault
  struct FeatureSupport {
    ::rs::google::protobuf::Edition edition_introduced_ = static_cast< ::rs::google::protobuf::Edition >(0);
    bool has_edition_introduced_ = false;
    ::rs::google::protobuf::Edition edition_deprecated_ = static_cast< ::rs::google::protobuf::Edition >(0);
    bool has_edition_deprecated_ = false;
    std::string deprecation_warning_;
    bool has_deprecation_warning_ = false;
    ::rs::google::protobuf::Edition edition_removed_ = static_cast< ::rs::google::protobuf::Edition >(0);
    bool has_edition_removed_ = false;

    FeatureSupport() = default;
    FeatureSupport(const FeatureSupport&) = default;
    FeatureSupport(FeatureSupport&&) = default;
    FeatureSupport& operator=(const FeatureSupport&) = default;
    FeatureSupport& operator=(FeatureSupport&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    ::rs::google::protobuf::Edition* mutable_edition_introduced() {
      has_edition_introduced_ = true;
      return &edition_introduced_;
    }
    void set_edition_introduced(const ::rs::google::protobuf::Edition& value);
    ::rs::google::protobuf::Edition* mutable_edition_deprecated() {
      has_edition_deprecated_ = true;
      return &edition_deprecated_;
    }
    void set_edition_deprecated(const ::rs::google::protobuf::Edition& value);
    std::string* mutable_deprecation_warning() {
      has_deprecation_warning_ = true;
      return &deprecation_warning_;
    }
    void set_deprecation_warning(const std::string& value);
    ::rs::google::protobuf::Edition* mutable_edition_removed() {
      has_edition_removed_ = true;
      return &edition_removed_;
    }
    void set_edition_removed(const ::rs::google::protobuf::Edition& value);
  };  // struct FeatureSupport
  ::rs::google::protobuf::FieldOptions::CType ctype_ = static_cast< ::rs::google::protobuf::FieldOptions::CType >(0);
  bool has_ctype_ = false;
  bool packed_ = false;
  bool has_packed_ = false;
  ::rs::google::protobuf::FieldOptions::JSType jstype_ = static_cast< ::rs::google::protobuf::FieldOptions::JSType >(0);
  bool has_jstype_ = false;
  bool lazy_ = false;
  bool has_lazy_ = false;
  bool unverified_lazy_ = false;
  bool has_unverified_lazy_ = false;
  bool deprecated_ = false;
  bool has_deprecated_ = false;
  bool weak_ = false;
  bool has_weak_ = false;
  bool debug_redact_ = false;
  bool has_debug_redact_ = false;
  ::rs::google::protobuf::FieldOptions::OptionRetention retention_ = static_cast< ::rs::google::protobuf::FieldOptions::OptionRetention >(0);
  bool has_retention_ = false;
  std::vector< ::rs::google::protobuf::FieldOptions::OptionTargetType > targets_;
  bool has_targets_ = false;
  std::vector< ::rs::google::protobuf::FieldOptions::EditionDefault > edition_defaults_;
  bool has_edition_defaults_ = false;
  ::rs::google::protobuf::FeatureSet features_;
  bool has_features_ = false;
  ::rs::google::protobuf::FieldOptions::FeatureSupport feature_support_;
  bool has_feature_support_ = false;
  std::vector< ::rs::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_ = false;

  FieldOptions() = default;
  FieldOptions(const FieldOptions&) = default;
  FieldOptions(FieldOptions&&) = default;
  FieldOptions& operator=(const FieldOptions&) = default;
  FieldOptions& operator=(FieldOptions&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::protobuf::FieldOptions::CType* mutable_ctype() {
    has_ctype_ = true;
    return &ctype_;
  }
  void set_ctype(const ::rs::google::protobuf::FieldOptions::CType& value);
  bool* mutable_packed() {
    has_packed_ = true;
    return &packed_;
  }
  void set_packed(const bool& value);
  ::rs::google::protobuf::FieldOptions::JSType* mutable_jstype() {
    has_jstype_ = true;
    return &jstype_;
  }
  void set_jstype(const ::rs::google::protobuf::FieldOptions::JSType& value);
  bool* mutable_lazy() {
    has_lazy_ = true;
    return &lazy_;
  }
  void set_lazy(const bool& value);
  bool* mutable_unverified_lazy() {
    has_unverified_lazy_ = true;
    return &unverified_lazy_;
  }
  void set_unverified_lazy(const bool& value);
  bool* mutable_deprecated() {
    has_deprecated_ = true;
    return &deprecated_;
  }
  void set_deprecated(const bool& value);
  bool* mutable_weak() {
    has_weak_ = true;
    return &weak_;
  }
  void set_weak(const bool& value);
  bool* mutable_debug_redact() {
    has_debug_redact_ = true;
    return &debug_redact_;
  }
  void set_debug_redact(const bool& value);
  ::rs::google::protobuf::FieldOptions::OptionRetention* mutable_retention() {
    has_retention_ = true;
    return &retention_;
  }
  void set_retention(const ::rs::google::protobuf::FieldOptions::OptionRetention& value);
  std::vector< ::rs::google::protobuf::FieldOptions::OptionTargetType >* mutable_targets() {
    has_targets_ = true;
    return &targets_;
  }
  void add_targets(const ::rs::google::protobuf::FieldOptions::OptionTargetType& value);
  void set_targets(const std::vector< ::rs::google::protobuf::FieldOptions::OptionTargetType >& value);
  std::vector< ::rs::google::protobuf::FieldOptions::EditionDefault >* mutable_edition_defaults() {
    has_edition_defaults_ = true;
    return &edition_defaults_;
  }
  void add_edition_defaults(const ::rs::google::protobuf::FieldOptions::EditionDefault& value);
  ::rs::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  ::rs::google::protobuf::FieldOptions::FeatureSupport* mutable_feature_support() {
    has_feature_support_ = true;
    return &feature_support_;
  }
  std::vector< ::rs::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::rs::google::protobuf::UninterpretedOption& value);
};  // struct FieldOptions
struct FieldDescriptorProto {
  enum Type {
    TYPE_DOUBLE = 1,
    TYPE_FLOAT = 2,
    TYPE_INT64 = 3,
    TYPE_UINT64 = 4,
    TYPE_INT32 = 5,
    TYPE_FIXED64 = 6,
    TYPE_FIXED32 = 7,
    TYPE_BOOL = 8,
    TYPE_STRING = 9,
    TYPE_GROUP = 10,
    TYPE_MESSAGE = 11,
    TYPE_BYTES = 12,
    TYPE_UINT32 = 13,
    TYPE_ENUM = 14,
    TYPE_SFIXED32 = 15,
    TYPE_SFIXED64 = 16,
    TYPE_SINT32 = 17,
    TYPE_SINT64 = 18,
  };

  enum Label {
    LABEL_OPTIONAL = 1,
    LABEL_REPEATED = 3,
    LABEL_REQUIRED = 2,
  };

  std::string name_;
  bool has_name_ = false;
  int32_t number_ = static_cast< int32_t >(0);
  bool has_number_ = false;
  ::rs::google::protobuf::FieldDescriptorProto::Label label_ = static_cast< ::rs::google::protobuf::FieldDescriptorProto::Label >(0);
  bool has_label_ = false;
  ::rs::google::protobuf::FieldDescriptorProto::Type type_ = static_cast< ::rs::google::protobuf::FieldDescriptorProto::Type >(0);
  bool has_type_ = false;
  std::string type_name_;
  bool has_type_name_ = false;
  std::string extendee_;
  bool has_extendee_ = false;
  std::string default_value_;
  bool has_default_value_ = false;
  int32_t oneof_index_ = static_cast< int32_t >(0);
  bool has_oneof_index_ = false;
  std::string json_name_;
  bool has_json_name_ = false;
  ::rs::google::protobuf::FieldOptions options_;
  bool has_options_ = false;
  bool proto3_optional_ = false;
  bool has_proto3_optional_ = false;

  FieldDescriptorProto() = default;
  FieldDescriptorProto(const FieldDescriptorProto&) = default;
  FieldDescriptorProto(FieldDescriptorProto&&) = default;
  FieldDescriptorProto& operator=(const FieldDescriptorProto&) = default;
  FieldDescriptorProto& operator=(FieldDescriptorProto&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  int32_t* mutable_number() {
    has_number_ = true;
    return &number_;
  }
  void set_number(const int32_t& value);
  ::rs::google::protobuf::FieldDescriptorProto::Label* mutable_label() {
    has_label_ = true;
    return &label_;
  }
  void set_label(const ::rs::google::protobuf::FieldDescriptorProto::Label& value);
  ::rs::google::protobuf::FieldDescriptorProto::Type* mutable_type() {
    has_type_ = true;
    return &type_;
  }
  void set_type(const ::rs::google::protobuf::FieldDescriptorProto::Type& value);
  std::string* mutable_type_name() {
    has_type_name_ = true;
    return &type_name_;
  }
  void set_type_name(const std::string& value);
  std::string* mutable_extendee() {
    has_extendee_ = true;
    return &extendee_;
  }
  void set_extendee(const std::string& value);
  std::string* mutable_default_value() {
    has_default_value_ = true;
    return &default_value_;
  }
  void set_default_value(const std::string& value);
  int32_t* mutable_oneof_index() {
    has_oneof_index_ = true;
    return &oneof_index_;
  }
  void set_oneof_index(const int32_t& value);
  std::string* mutable_json_name() {
    has_json_name_ = true;
    return &json_name_;
  }
  void set_json_name(const std::string& value);
  ::rs::google::protobuf::FieldOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
  bool* mutable_proto3_optional() {
    has_proto3_optional_ = true;
    return &proto3_optional_;
  }
  void set_proto3_optional(const bool& value);
};  // struct FieldDescriptorProto
struct OneofOptions {
  ::rs::google::protobuf::FeatureSet features_;
  bool has_features_ = false;
  std::vector< ::rs::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_ = false;

  OneofOptions() = default;
  OneofOptions(const OneofOptions&) = default;
  OneofOptions(OneofOptions&&) = default;
  OneofOptions& operator=(const OneofOptions&) = default;
  OneofOptions& operator=(OneofOptions&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  std::vector< ::rs::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::rs::google::protobuf::UninterpretedOption& value);
};  // struct OneofOptions
struct OneofDescriptorProto {
  std::string name_;
  bool has_name_ = false;
  ::rs::google::protobuf::OneofOptions options_;
  bool has_options_ = false;

  OneofDescriptorProto() = default;
  OneofDescriptorProto(const OneofDescriptorProto&) = default;
  OneofDescriptorProto(OneofDescriptorProto&&) = default;
  OneofDescriptorProto& operator=(const OneofDescriptorProto&) = default;
  OneofDescriptorProto& operator=(OneofDescriptorProto&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::protobuf::OneofOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
};  // struct OneofDescriptorProto
struct EnumOptions {
  bool allow_alias_ = false;
  bool has_allow_alias_ = false;
  bool deprecated_ = false;
  bool has_deprecated_ = false;
  bool deprecated_legacy_json_field_conflicts_ = false;
  bool has_deprecated_legacy_json_field_conflicts_ = false;
  ::rs::google::protobuf::FeatureSet features_;
  bool has_features_ = false;
  std::vector< ::rs::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_ = false;

  EnumOptions() = default;
  EnumOptions(const EnumOptions&) = default;
  EnumOptions(EnumOptions&&) = default;
  EnumOptions& operator=(const EnumOptions&) = default;
  EnumOptions& operator=(EnumOptions&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_allow_alias() {
    has_allow_alias_ = true;
    return &allow_alias_;
  }
  void set_allow_alias(const bool& value);
  bool* mutable_deprecated() {
    has_deprecated_ = true;
    return &deprecated_;
  }
  void set_deprecated(const bool& value);
  bool* mutable_deprecated_legacy_json_field_conflicts() {
    has_deprecated_legacy_json_field_conflicts_ = true;
    return &deprecated_legacy_json_field_conflicts_;
  }
  void set_deprecated_legacy_json_field_conflicts(const bool& value);
  ::rs::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  std::vector< ::rs::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::rs::google::protobuf::UninterpretedOption& value);
};  // struct EnumOptions
struct EnumDescriptorProto {
  struct EnumReservedRange {
    int32_t start_ = static_cast< int32_t >(0);
    bool has_start_ = false;
    int32_t end_ = static_cast< int32_t >(0);
    bool has_end_ = false;

    EnumReservedRange() = default;
    EnumReservedRange(const EnumReservedRange&) = default;
    EnumReservedRange(EnumReservedRange&&) = default;
    EnumReservedRange& operator=(const EnumReservedRange&) = default;
    EnumReservedRange& operator=(EnumReservedRange&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int32_t* mutable_start() {
      has_start_ = true;
      return &start_;
    }
    void set_start(const int32_t& value);
    int32_t* mutable_end() {
      has_end_ = true;
      return &end_;
    }
    void set_end(const int32_t& value);
  };  // struct EnumReservedRange
  std::string name_;
  bool has_name_ = false;
  std::vector< ::rs::google::protobuf::EnumValueDescriptorProto > value_;
  bool has_value_ = false;
  ::rs::google::protobuf::EnumOptions options_;
  bool has_options_ = false;
  std::vector< ::rs::google::protobuf::EnumDescriptorProto::EnumReservedRange > reserved_range_;
  bool has_reserved_range_ = false;
  std::vector< std::string > reserved_name_;
  bool has_reserved_name_ = false;

  EnumDescriptorProto() = default;
  EnumDescriptorProto(const EnumDescriptorProto&) = default;
  EnumDescriptorProto(EnumDescriptorProto&&) = default;
  EnumDescriptorProto& operator=(const EnumDescriptorProto&) = default;
  EnumDescriptorProto& operator=(EnumDescriptorProto&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::vector< ::rs::google::protobuf::EnumValueDescriptorProto >* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void add_value(const ::rs::google::protobuf::EnumValueDescriptorProto& value);
  ::rs::google::protobuf::EnumOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
  std::vector< ::rs::google::protobuf::EnumDescriptorProto::EnumReservedRange >* mutable_reserved_range() {
    has_reserved_range_ = true;
    return &reserved_range_;
  }
  void add_reserved_range(const ::rs::google::protobuf::EnumDescriptorProto::EnumReservedRange& value);
  std::vector< std::string >* mutable_reserved_name() {
    has_reserved_name_ = true;
    return &reserved_name_;
  }
  void add_reserved_name(const std::string& value);
  void set_reserved_name(const std::vector< std::string >& value);
};  // struct EnumDescriptorProto
struct EnumValueOptions {
  bool deprecated_ = false;
  bool has_deprecated_ = false;
  ::rs::google::protobuf::FeatureSet features_;
  bool has_features_ = false;
  bool debug_redact_ = false;
  bool has_debug_redact_ = false;
  ::rs::google::protobuf::FieldOptions::FeatureSupport feature_support_;
  bool has_feature_support_ = false;
  std::vector< ::rs::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_ = false;

  EnumValueOptions() = default;
  EnumValueOptions(const EnumValueOptions&) = default;
  EnumValueOptions(EnumValueOptions&&) = default;
  EnumValueOptions& operator=(const EnumValueOptions&) = default;
  EnumValueOptions& operator=(EnumValueOptions&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_deprecated() {
    has_deprecated_ = true;
    return &deprecated_;
  }
  void set_deprecated(const bool& value);
  ::rs::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  bool* mutable_debug_redact() {
    has_debug_redact_ = true;
    return &debug_redact_;
  }
  void set_debug_redact(const bool& value);
  ::rs::google::protobuf::FieldOptions::FeatureSupport* mutable_feature_support() {
    has_feature_support_ = true;
    return &feature_support_;
  }
  std::vector< ::rs::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::rs::google::protobuf::UninterpretedOption& value);
};  // struct EnumValueOptions
struct EnumValueDescriptorProto {
  std::string name_;
  bool has_name_ = false;
  int32_t number_ = static_cast< int32_t >(0);
  bool has_number_ = false;
  ::rs::google::protobuf::EnumValueOptions options_;
  bool has_options_ = false;

  EnumValueDescriptorProto() = default;
  EnumValueDescriptorProto(const EnumValueDescriptorProto&) = default;
  EnumValueDescriptorProto(EnumValueDescriptorProto&&) = default;
  EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto&) = default;
  EnumValueDescriptorProto& operator=(EnumValueDescriptorProto&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  int32_t* mutable_number() {
    has_number_ = true;
    return &number_;
  }
  void set_number(const int32_t& value);
  ::rs::google::protobuf::EnumValueOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
};  // struct EnumValueDescriptorProto
struct ServiceOptions {
  ::rs::google::protobuf::FeatureSet features_;
  bool has_features_ = false;
  bool deprecated_ = false;
  bool has_deprecated_ = false;
  std::vector< ::rs::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_ = false;

  ServiceOptions() = default;
  ServiceOptions(const ServiceOptions&) = default;
  ServiceOptions(ServiceOptions&&) = default;
  ServiceOptions& operator=(const ServiceOptions&) = default;
  ServiceOptions& operator=(ServiceOptions&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  bool* mutable_deprecated() {
    has_deprecated_ = true;
    return &deprecated_;
  }
  void set_deprecated(const bool& value);
  std::vector< ::rs::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::rs::google::protobuf::UninterpretedOption& value);
};  // struct ServiceOptions
struct ServiceDescriptorProto {
  std::string name_;
  bool has_name_ = false;
  std::vector< ::rs::google::protobuf::MethodDescriptorProto > method_;
  bool has_method_ = false;
  ::rs::google::protobuf::ServiceOptions options_;
  bool has_options_ = false;

  ServiceDescriptorProto() = default;
  ServiceDescriptorProto(const ServiceDescriptorProto&) = default;
  ServiceDescriptorProto(ServiceDescriptorProto&&) = default;
  ServiceDescriptorProto& operator=(const ServiceDescriptorProto&) = default;
  ServiceDescriptorProto& operator=(ServiceDescriptorProto&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::vector< ::rs::google::protobuf::MethodDescriptorProto >* mutable_method() {
    has_method_ = true;
    return &method_;
  }
  void add_method(const ::rs::google::protobuf::MethodDescriptorProto& value);
  ::rs::google::protobuf::ServiceOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
};  // struct ServiceDescriptorProto
struct MethodOptions {
  enum IdempotencyLevel {
    IDEMPOTENCY_UNKNOWN = 0,
    NO_SIDE_EFFECTS = 1,
    IDEMPOTENT = 2,
  };

  bool deprecated_ = false;
  bool has_deprecated_ = false;
  ::rs::google::protobuf::MethodOptions::IdempotencyLevel idempotency_level_ = static_cast< ::rs::google::protobuf::MethodOptions::IdempotencyLevel >(0);
  bool has_idempotency_level_ = false;
  ::rs::google::protobuf::FeatureSet features_;
  bool has_features_ = false;
  std::vector< ::rs::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_ = false;

  MethodOptions() = default;
  MethodOptions(const MethodOptions&) = default;
  MethodOptions(MethodOptions&&) = default;
  MethodOptions& operator=(const MethodOptions&) = default;
  MethodOptions& operator=(MethodOptions&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_deprecated() {
    has_deprecated_ = true;
    return &deprecated_;
  }
  void set_deprecated(const bool& value);
  ::rs::google::protobuf::MethodOptions::IdempotencyLevel* mutable_idempotency_level() {
    has_idempotency_level_ = true;
    return &idempotency_level_;
  }
  void set_idempotency_level(const ::rs::google::protobuf::MethodOptions::IdempotencyLevel& value);
  ::rs::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  std::vector< ::rs::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::rs::google::protobuf::UninterpretedOption& value);
};  // struct MethodOptions
struct MethodDescriptorProto {
  std::string name_;
  bool has_name_ = false;
  std::string input_type_;
  bool has_input_type_ = false;
  std::string output_type_;
  bool has_output_type_ = false;
  ::rs::google::protobuf::MethodOptions options_;
  bool has_options_ = false;
  bool client_streaming_ = false;
  bool has_client_streaming_ = false;
  bool server_streaming_ = false;
  bool has_server_streaming_ = false;

  MethodDescriptorProto() = default;
  MethodDescriptorProto(const MethodDescriptorProto&) = default;
  MethodDescriptorProto(MethodDescriptorProto&&) = default;
  MethodDescriptorProto& operator=(const MethodDescriptorProto&) = default;
  MethodDescriptorProto& operator=(MethodDescriptorProto&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::string* mutable_input_type() {
    has_input_type_ = true;
    return &input_type_;
  }
  void set_input_type(const std::string& value);
  std::string* mutable_output_type() {
    has_output_type_ = true;
    return &output_type_;
  }
  void set_output_type(const std::string& value);
  ::rs::google::protobuf::MethodOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
  bool* mutable_client_streaming() {
    has_client_streaming_ = true;
    return &client_streaming_;
  }
  void set_client_streaming(const bool& value);
  bool* mutable_server_streaming() {
    has_server_streaming_ = true;
    return &server_streaming_;
  }
  void set_server_streaming(const bool& value);
};  // struct MethodDescriptorProto
struct UninterpretedOption {
  struct NamePart {
    std::string name_part_;
    bool has_name_part_ = false;
    bool is_extension_ = false;
    bool has_is_extension_ = false;

    NamePart() = default;
    NamePart(const NamePart&) = default;
    NamePart(NamePart&&) = default;
    NamePart& operator=(const NamePart&) = default;
    NamePart& operator=(NamePart&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_name_part() {
      has_name_part_ = true;
      return &name_part_;
    }
    void set_name_part(const std::string& value);
    bool* mutable_is_extension() {
      has_is_extension_ = true;
      return &is_extension_;
    }
    void set_is_extension(const bool& value);
  };  // struct NamePart
  std::vector< ::rs::google::protobuf::UninterpretedOption::NamePart > name_;
  bool has_name_ = false;
  std::string identifier_value_;
  bool has_identifier_value_ = false;
  uint64_t positive_int_value_ = static_cast< uint64_t >(0);
  bool has_positive_int_value_ = false;
  int64_t negative_int_value_ = static_cast< int64_t >(0);
  bool has_negative_int_value_ = false;
  double double_value_ = static_cast< double >(0);
  bool has_double_value_ = false;
  std::string string_value_;
  bool has_string_value_ = false;
  std::string aggregate_value_;
  bool has_aggregate_value_ = false;

  UninterpretedOption() = default;
  UninterpretedOption(const UninterpretedOption&) = default;
  UninterpretedOption(UninterpretedOption&&) = default;
  UninterpretedOption& operator=(const UninterpretedOption&) = default;
  UninterpretedOption& operator=(UninterpretedOption&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::protobuf::UninterpretedOption::NamePart >* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void add_name(const ::rs::google::protobuf::UninterpretedOption::NamePart& value);
  std::string* mutable_identifier_value() {
    has_identifier_value_ = true;
    return &identifier_value_;
  }
  void set_identifier_value(const std::string& value);
  uint64_t* mutable_positive_int_value() {
    has_positive_int_value_ = true;
    return &positive_int_value_;
  }
  void set_positive_int_value(const uint64_t& value);
  int64_t* mutable_negative_int_value() {
    has_negative_int_value_ = true;
    return &negative_int_value_;
  }
  void set_negative_int_value(const int64_t& value);
  double* mutable_double_value() {
    has_double_value_ = true;
    return &double_value_;
  }
  void set_double_value(const double& value);
  std::string* mutable_string_value() {
    has_string_value_ = true;
    return &string_value_;
  }
  void set_string_value(const std::string& value);
  std::string* mutable_aggregate_value() {
    has_aggregate_value_ = true;
    return &aggregate_value_;
  }
  void set_aggregate_value(const std::string& value);
};  // struct UninterpretedOption
struct FeatureSetDefaults {
  struct FeatureSetEditionDefault {
    ::rs::google::protobuf::Edition edition_ = static_cast< ::rs::google::protobuf::Edition >(0);
    bool has_edition_ = false;
    ::rs::google::protobuf::FeatureSet overridable_features_;
    bool has_overridable_features_ = false;
    ::rs::google::protobuf::FeatureSet fixed_features_;
    bool has_fixed_features_ = false;

    FeatureSetEditionDefault() = default;
    FeatureSetEditionDefault(const FeatureSetEditionDefault&) = default;
    FeatureSetEditionDefault(FeatureSetEditionDefault&&) = default;
    FeatureSetEditionDefault& operator=(const FeatureSetEditionDefault&) = default;
    FeatureSetEditionDefault& operator=(FeatureSetEditionDefault&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    ::rs::google::protobuf::Edition* mutable_edition() {
      has_edition_ = true;
      return &edition_;
    }
    void set_edition(const ::rs::google::protobuf::Edition& value);
    ::rs::google::protobuf::FeatureSet* mutable_overridable_features() {
      has_overridable_features_ = true;
      return &overridable_features_;
    }
    ::rs::google::protobuf::FeatureSet* mutable_fixed_features() {
      has_fixed_features_ = true;
      return &fixed_features_;
    }
  };  // struct FeatureSetEditionDefault
  std::vector< ::rs::google::protobuf::FeatureSetDefaults::FeatureSetEditionDefault > defaults_;
  bool has_defaults_ = false;
  ::rs::google::protobuf::Edition minimum_edition_ = static_cast< ::rs::google::protobuf::Edition >(0);
  bool has_minimum_edition_ = false;
  ::rs::google::protobuf::Edition maximum_edition_ = static_cast< ::rs::google::protobuf::Edition >(0);
  bool has_maximum_edition_ = false;

  FeatureSetDefaults() = default;
  FeatureSetDefaults(const FeatureSetDefaults&) = default;
  FeatureSetDefaults(FeatureSetDefaults&&) = default;
  FeatureSetDefaults& operator=(const FeatureSetDefaults&) = default;
  FeatureSetDefaults& operator=(FeatureSetDefaults&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::protobuf::FeatureSetDefaults::FeatureSetEditionDefault >* mutable_defaults() {
    has_defaults_ = true;
    return &defaults_;
  }
  void add_defaults(const ::rs::google::protobuf::FeatureSetDefaults::FeatureSetEditionDefault& value);
  ::rs::google::protobuf::Edition* mutable_minimum_edition() {
    has_minimum_edition_ = true;
    return &minimum_edition_;
  }
  void set_minimum_edition(const ::rs::google::protobuf::Edition& value);
  ::rs::google::protobuf::Edition* mutable_maximum_edition() {
    has_maximum_edition_ = true;
    return &maximum_edition_;
  }
  void set_maximum_edition(const ::rs::google::protobuf::Edition& value);
};  // struct FeatureSetDefaults
struct GeneratedCodeInfo {
  struct Annotation {
    enum Semantic {
      NONE = 0,
      SET = 1,
      ALIAS = 2,
    };

    std::vector< int32_t > path_;
    bool has_path_ = false;
    std::string source_file_;
    bool has_source_file_ = false;
    int32_t begin_ = static_cast< int32_t >(0);
    bool has_begin_ = false;
    int32_t end_ = static_cast< int32_t >(0);
    bool has_end_ = false;
    ::rs::google::protobuf::GeneratedCodeInfo::Annotation::Semantic semantic_ = static_cast< ::rs::google::protobuf::GeneratedCodeInfo::Annotation::Semantic >(0);
    bool has_semantic_ = false;

    Annotation() = default;
    Annotation(const Annotation&) = default;
    Annotation(Annotation&&) = default;
    Annotation& operator=(const Annotation&) = default;
    Annotation& operator=(Annotation&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::vector< int32_t >* mutable_path() {
      has_path_ = true;
      return &path_;
    }
    void add_path(const int32_t& value);
    void set_path(const std::vector< int32_t >& value);
    std::string* mutable_source_file() {
      has_source_file_ = true;
      return &source_file_;
    }
    void set_source_file(const std::string& value);
    int32_t* mutable_begin() {
      has_begin_ = true;
      return &begin_;
    }
    void set_begin(const int32_t& value);
    int32_t* mutable_end() {
      has_end_ = true;
      return &end_;
    }
    void set_end(const int32_t& value);
    ::rs::google::protobuf::GeneratedCodeInfo::Annotation::Semantic* mutable_semantic() {
      has_semantic_ = true;
      return &semantic_;
    }
    void set_semantic(const ::rs::google::protobuf::GeneratedCodeInfo::Annotation::Semantic& value);
  };  // struct Annotation
  std::vector< ::rs::google::protobuf::GeneratedCodeInfo::Annotation > annotation_;
  bool has_annotation_ = false;

  GeneratedCodeInfo() = default;
  GeneratedCodeInfo(const GeneratedCodeInfo&) = default;
  GeneratedCodeInfo(GeneratedCodeInfo&&) = default;
  GeneratedCodeInfo& operator=(const GeneratedCodeInfo&) = default;
  GeneratedCodeInfo& operator=(GeneratedCodeInfo&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::protobuf::GeneratedCodeInfo::Annotation >* mutable_annotation() {
    has_annotation_ = true;
    return &annotation_;
  }
  void add_annotation(const ::rs::google::protobuf::GeneratedCodeInfo::Annotation& value);
};  // struct GeneratedCodeInfo
}  // namespace protobuf
}  // namespace google
namespace google {
namespace api {
}  // namespace api
}  // namespace google
namespace google {
namespace api {
enum LaunchStage {
  LAUNCH_STAGE_UNSPECIFIED = 0,
  UNIMPLEMENTED = 6,
  PRELAUNCH = 7,
  EARLY_ACCESS = 1,
  ALPHA = 2,
  BETA = 3,
  GA = 4,
  DEPRECATED = 5,
};

}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
struct Duration {
  int64_t seconds_ = static_cast< int64_t >(0);
  bool has_seconds_ = false;
  int32_t nanos_ = static_cast< int32_t >(0);
  bool has_nanos_ = false;

  Duration() = default;
  Duration(const Duration&) = default;
  Duration(Duration&&) = default;
  Duration& operator=(const Duration&) = default;
  Duration& operator=(Duration&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  int64_t* mutable_seconds() {
    has_seconds_ = true;
    return &seconds_;
  }
  void set_seconds(const int64_t& value);
  int32_t* mutable_nanos() {
    has_nanos_ = true;
    return &nanos_;
  }
  void set_nanos(const int32_t& value);
};  // struct Duration
}  // namespace protobuf
}  // namespace google
namespace google {
namespace api {
enum ClientLibraryOrganization {
  CLIENT_LIBRARY_ORGANIZATION_UNSPECIFIED = 0,
  CLOUD = 1,
  ADS = 2,
  PHOTOS = 3,
  STREET_VIEW = 4,
  SHOPPING = 5,
  GEO = 6,
  GENERATIVE_AI = 7,
};

enum ClientLibraryDestination {
  CLIENT_LIBRARY_DESTINATION_UNSPECIFIED = 0,
  GITHUB = 10,
  PACKAGE_MANAGER = 20,
};

struct SelectiveGapicGeneration {
  std::vector< std::string > methods_;
  bool has_methods_ = false;
  bool generate_omitted_as_internal_ = false;
  bool has_generate_omitted_as_internal_ = false;

  SelectiveGapicGeneration() = default;
  SelectiveGapicGeneration(const SelectiveGapicGeneration&) = default;
  SelectiveGapicGeneration(SelectiveGapicGeneration&&) = default;
  SelectiveGapicGeneration& operator=(const SelectiveGapicGeneration&) = default;
  SelectiveGapicGeneration& operator=(SelectiveGapicGeneration&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< std::string >* mutable_methods() {
    has_methods_ = true;
    return &methods_;
  }
  void add_methods(const std::string& value);
  void set_methods(const std::vector< std::string >& value);
  bool* mutable_generate_omitted_as_internal() {
    has_generate_omitted_as_internal_ = true;
    return &generate_omitted_as_internal_;
  }
  void set_generate_omitted_as_internal(const bool& value);
};  // struct SelectiveGapicGeneration
struct CommonLanguageSettings {
  std::string reference_docs_uri_;
  bool has_reference_docs_uri_ = false;
  std::vector< ::rs::google::api::ClientLibraryDestination > destinations_;
  bool has_destinations_ = false;
  ::rs::google::api::SelectiveGapicGeneration selective_gapic_generation_;
  bool has_selective_gapic_generation_ = false;

  CommonLanguageSettings() = default;
  CommonLanguageSettings(const CommonLanguageSettings&) = default;
  CommonLanguageSettings(CommonLanguageSettings&&) = default;
  CommonLanguageSettings& operator=(const CommonLanguageSettings&) = default;
  CommonLanguageSettings& operator=(CommonLanguageSettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_reference_docs_uri() {
    has_reference_docs_uri_ = true;
    return &reference_docs_uri_;
  }
  void set_reference_docs_uri(const std::string& value);
  std::vector< ::rs::google::api::ClientLibraryDestination >* mutable_destinations() {
    has_destinations_ = true;
    return &destinations_;
  }
  void add_destinations(const ::rs::google::api::ClientLibraryDestination& value);
  void set_destinations(const std::vector< ::rs::google::api::ClientLibraryDestination >& value);
  ::rs::google::api::SelectiveGapicGeneration* mutable_selective_gapic_generation() {
    has_selective_gapic_generation_ = true;
    return &selective_gapic_generation_;
  }
};  // struct CommonLanguageSettings
struct CppSettings {
  ::rs::google::api::CommonLanguageSettings common_;
  bool has_common_ = false;

  CppSettings() = default;
  CppSettings(const CppSettings&) = default;
  CppSettings(CppSettings&&) = default;
  CppSettings& operator=(const CppSettings&) = default;
  CppSettings& operator=(CppSettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::api::CommonLanguageSettings* mutable_common() {
    has_common_ = true;
    return &common_;
  }
};  // struct CppSettings
struct DotnetSettings {
  struct RenamedServicesEntry {
    std::string key_;
    bool has_key_ = false;
    std::string value_;
    bool has_value_ = false;

    RenamedServicesEntry() = default;
    RenamedServicesEntry(const RenamedServicesEntry&) = default;
    RenamedServicesEntry(RenamedServicesEntry&&) = default;
    RenamedServicesEntry& operator=(const RenamedServicesEntry&) = default;
    RenamedServicesEntry& operator=(RenamedServicesEntry&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_key() {
      has_key_ = true;
      return &key_;
    }
    void set_key(const std::string& value);
    std::string* mutable_value() {
      has_value_ = true;
      return &value_;
    }
    void set_value(const std::string& value);
  };  // struct RenamedServicesEntry
  struct RenamedResourcesEntry {
    std::string key_;
    bool has_key_ = false;
    std::string value_;
    bool has_value_ = false;

    RenamedResourcesEntry() = default;
    RenamedResourcesEntry(const RenamedResourcesEntry&) = default;
    RenamedResourcesEntry(RenamedResourcesEntry&&) = default;
    RenamedResourcesEntry& operator=(const RenamedResourcesEntry&) = default;
    RenamedResourcesEntry& operator=(RenamedResourcesEntry&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_key() {
      has_key_ = true;
      return &key_;
    }
    void set_key(const std::string& value);
    std::string* mutable_value() {
      has_value_ = true;
      return &value_;
    }
    void set_value(const std::string& value);
  };  // struct RenamedResourcesEntry
  ::rs::google::api::CommonLanguageSettings common_;
  bool has_common_ = false;
  std::vector< ::rs::google::api::DotnetSettings::RenamedServicesEntry > renamed_services_;
  bool has_renamed_services_ = false;
  std::vector< ::rs::google::api::DotnetSettings::RenamedResourcesEntry > renamed_resources_;
  bool has_renamed_resources_ = false;
  std::vector< std::string > ignored_resources_;
  bool has_ignored_resources_ = false;
  std::vector< std::string > forced_namespace_aliases_;
  bool has_forced_namespace_aliases_ = false;
  std::vector< std::string > handwritten_signatures_;
  bool has_handwritten_signatures_ = false;

  DotnetSettings() = default;
  DotnetSettings(const DotnetSettings&) = default;
  DotnetSettings(DotnetSettings&&) = default;
  DotnetSettings& operator=(const DotnetSettings&) = default;
  DotnetSettings& operator=(DotnetSettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::api::CommonLanguageSettings* mutable_common() {
    has_common_ = true;
    return &common_;
  }
  std::vector< ::rs::google::api::DotnetSettings::RenamedServicesEntry >* mutable_renamed_services() {
    has_renamed_services_ = true;
    return &renamed_services_;
  }
  void add_renamed_services(const ::rs::google::api::DotnetSettings::RenamedServicesEntry& value);
  std::vector< ::rs::google::api::DotnetSettings::RenamedResourcesEntry >* mutable_renamed_resources() {
    has_renamed_resources_ = true;
    return &renamed_resources_;
  }
  void add_renamed_resources(const ::rs::google::api::DotnetSettings::RenamedResourcesEntry& value);
  std::vector< std::string >* mutable_ignored_resources() {
    has_ignored_resources_ = true;
    return &ignored_resources_;
  }
  void add_ignored_resources(const std::string& value);
  void set_ignored_resources(const std::vector< std::string >& value);
  std::vector< std::string >* mutable_forced_namespace_aliases() {
    has_forced_namespace_aliases_ = true;
    return &forced_namespace_aliases_;
  }
  void add_forced_namespace_aliases(const std::string& value);
  void set_forced_namespace_aliases(const std::vector< std::string >& value);
  std::vector< std::string >* mutable_handwritten_signatures() {
    has_handwritten_signatures_ = true;
    return &handwritten_signatures_;
  }
  void add_handwritten_signatures(const std::string& value);
  void set_handwritten_signatures(const std::vector< std::string >& value);
};  // struct DotnetSettings
struct GoSettings {
  struct RenamedServicesEntry {
    std::string key_;
    bool has_key_ = false;
    std::string value_;
    bool has_value_ = false;

    RenamedServicesEntry() = default;
    RenamedServicesEntry(const RenamedServicesEntry&) = default;
    RenamedServicesEntry(RenamedServicesEntry&&) = default;
    RenamedServicesEntry& operator=(const RenamedServicesEntry&) = default;
    RenamedServicesEntry& operator=(RenamedServicesEntry&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_key() {
      has_key_ = true;
      return &key_;
    }
    void set_key(const std::string& value);
    std::string* mutable_value() {
      has_value_ = true;
      return &value_;
    }
    void set_value(const std::string& value);
  };  // struct RenamedServicesEntry
  ::rs::google::api::CommonLanguageSettings common_;
  bool has_common_ = false;
  std::vector< ::rs::google::api::GoSettings::RenamedServicesEntry > renamed_services_;
  bool has_renamed_services_ = false;

  GoSettings() = default;
  GoSettings(const GoSettings&) = default;
  GoSettings(GoSettings&&) = default;
  GoSettings& operator=(const GoSettings&) = default;
  GoSettings& operator=(GoSettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::api::CommonLanguageSettings* mutable_common() {
    has_common_ = true;
    return &common_;
  }
  std::vector< ::rs::google::api::GoSettings::RenamedServicesEntry >* mutable_renamed_services() {
    has_renamed_services_ = true;
    return &renamed_services_;
  }
  void add_renamed_services(const ::rs::google::api::GoSettings::RenamedServicesEntry& value);
};  // struct GoSettings
struct JavaSettings {
  struct ServiceClassNamesEntry {
    std::string key_;
    bool has_key_ = false;
    std::string value_;
    bool has_value_ = false;

    ServiceClassNamesEntry() = default;
    ServiceClassNamesEntry(const ServiceClassNamesEntry&) = default;
    ServiceClassNamesEntry(ServiceClassNamesEntry&&) = default;
    ServiceClassNamesEntry& operator=(const ServiceClassNamesEntry&) = default;
    ServiceClassNamesEntry& operator=(ServiceClassNamesEntry&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_key() {
      has_key_ = true;
      return &key_;
    }
    void set_key(const std::string& value);
    std::string* mutable_value() {
      has_value_ = true;
      return &value_;
    }
    void set_value(const std::string& value);
  };  // struct ServiceClassNamesEntry
  std::string library_package_;
  bool has_library_package_ = false;
  std::vector< ::rs::google::api::JavaSettings::ServiceClassNamesEntry > service_class_names_;
  bool has_service_class_names_ = false;
  ::rs::google::api::CommonLanguageSettings common_;
  bool has_common_ = false;

  JavaSettings() = default;
  JavaSettings(const JavaSettings&) = default;
  JavaSettings(JavaSettings&&) = default;
  JavaSettings& operator=(const JavaSettings&) = default;
  JavaSettings& operator=(JavaSettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_library_package() {
    has_library_package_ = true;
    return &library_package_;
  }
  void set_library_package(const std::string& value);
  std::vector< ::rs::google::api::JavaSettings::ServiceClassNamesEntry >* mutable_service_class_names() {
    has_service_class_names_ = true;
    return &service_class_names_;
  }
  void add_service_class_names(const ::rs::google::api::JavaSettings::ServiceClassNamesEntry& value);
  ::rs::google::api::CommonLanguageSettings* mutable_common() {
    has_common_ = true;
    return &common_;
  }
};  // struct JavaSettings
struct NodeSettings {
  ::rs::google::api::CommonLanguageSettings common_;
  bool has_common_ = false;

  NodeSettings() = default;
  NodeSettings(const NodeSettings&) = default;
  NodeSettings(NodeSettings&&) = default;
  NodeSettings& operator=(const NodeSettings&) = default;
  NodeSettings& operator=(NodeSettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::api::CommonLanguageSettings* mutable_common() {
    has_common_ = true;
    return &common_;
  }
};  // struct NodeSettings
struct PhpSettings {
  ::rs::google::api::CommonLanguageSettings common_;
  bool has_common_ = false;

  PhpSettings() = default;
  PhpSettings(const PhpSettings&) = default;
  PhpSettings(PhpSettings&&) = default;
  PhpSettings& operator=(const PhpSettings&) = default;
  PhpSettings& operator=(PhpSettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::api::CommonLanguageSettings* mutable_common() {
    has_common_ = true;
    return &common_;
  }
};  // struct PhpSettings
struct PythonSettings {
  struct ExperimentalFeatures {
    bool rest_async_io_enabled_ = false;
    bool has_rest_async_io_enabled_ = false;
    bool protobuf_pythonic_types_enabled_ = false;
    bool has_protobuf_pythonic_types_enabled_ = false;
    bool unversioned_package_disabled_ = false;
    bool has_unversioned_package_disabled_ = false;

    ExperimentalFeatures() = default;
    ExperimentalFeatures(const ExperimentalFeatures&) = default;
    ExperimentalFeatures(ExperimentalFeatures&&) = default;
    ExperimentalFeatures& operator=(const ExperimentalFeatures&) = default;
    ExperimentalFeatures& operator=(ExperimentalFeatures&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    bool* mutable_rest_async_io_enabled() {
      has_rest_async_io_enabled_ = true;
      return &rest_async_io_enabled_;
    }
    void set_rest_async_io_enabled(const bool& value);
    bool* mutable_protobuf_pythonic_types_enabled() {
      has_protobuf_pythonic_types_enabled_ = true;
      return &protobuf_pythonic_types_enabled_;
    }
    void set_protobuf_pythonic_types_enabled(const bool& value);
    bool* mutable_unversioned_package_disabled() {
      has_unversioned_package_disabled_ = true;
      return &unversioned_package_disabled_;
    }
    void set_unversioned_package_disabled(const bool& value);
  };  // struct ExperimentalFeatures
  ::rs::google::api::CommonLanguageSettings common_;
  bool has_common_ = false;
  ::rs::google::api::PythonSettings::ExperimentalFeatures experimental_features_;
  bool has_experimental_features_ = false;

  PythonSettings() = default;
  PythonSettings(const PythonSettings&) = default;
  PythonSettings(PythonSettings&&) = default;
  PythonSettings& operator=(const PythonSettings&) = default;
  PythonSettings& operator=(PythonSettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::api::CommonLanguageSettings* mutable_common() {
    has_common_ = true;
    return &common_;
  }
  ::rs::google::api::PythonSettings::ExperimentalFeatures* mutable_experimental_features() {
    has_experimental_features_ = true;
    return &experimental_features_;
  }
};  // struct PythonSettings
struct RubySettings {
  ::rs::google::api::CommonLanguageSettings common_;
  bool has_common_ = false;

  RubySettings() = default;
  RubySettings(const RubySettings&) = default;
  RubySettings(RubySettings&&) = default;
  RubySettings& operator=(const RubySettings&) = default;
  RubySettings& operator=(RubySettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::api::CommonLanguageSettings* mutable_common() {
    has_common_ = true;
    return &common_;
  }
};  // struct RubySettings
struct ClientLibrarySettings {
  std::string version_;
  bool has_version_ = false;
  ::rs::google::api::LaunchStage launch_stage_ = static_cast< ::rs::google::api::LaunchStage >(0);
  bool has_launch_stage_ = false;
  bool rest_numeric_enums_ = false;
  bool has_rest_numeric_enums_ = false;
  ::rs::google::api::JavaSettings java_settings_;
  bool has_java_settings_ = false;
  ::rs::google::api::CppSettings cpp_settings_;
  bool has_cpp_settings_ = false;
  ::rs::google::api::PhpSettings php_settings_;
  bool has_php_settings_ = false;
  ::rs::google::api::PythonSettings python_settings_;
  bool has_python_settings_ = false;
  ::rs::google::api::NodeSettings node_settings_;
  bool has_node_settings_ = false;
  ::rs::google::api::DotnetSettings dotnet_settings_;
  bool has_dotnet_settings_ = false;
  ::rs::google::api::RubySettings ruby_settings_;
  bool has_ruby_settings_ = false;
  ::rs::google::api::GoSettings go_settings_;
  bool has_go_settings_ = false;

  ClientLibrarySettings() = default;
  ClientLibrarySettings(const ClientLibrarySettings&) = default;
  ClientLibrarySettings(ClientLibrarySettings&&) = default;
  ClientLibrarySettings& operator=(const ClientLibrarySettings&) = default;
  ClientLibrarySettings& operator=(ClientLibrarySettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_version() {
    has_version_ = true;
    return &version_;
  }
  void set_version(const std::string& value);
  ::rs::google::api::LaunchStage* mutable_launch_stage() {
    has_launch_stage_ = true;
    return &launch_stage_;
  }
  void set_launch_stage(const ::rs::google::api::LaunchStage& value);
  bool* mutable_rest_numeric_enums() {
    has_rest_numeric_enums_ = true;
    return &rest_numeric_enums_;
  }
  void set_rest_numeric_enums(const bool& value);
  ::rs::google::api::JavaSettings* mutable_java_settings() {
    has_java_settings_ = true;
    return &java_settings_;
  }
  ::rs::google::api::CppSettings* mutable_cpp_settings() {
    has_cpp_settings_ = true;
    return &cpp_settings_;
  }
  ::rs::google::api::PhpSettings* mutable_php_settings() {
    has_php_settings_ = true;
    return &php_settings_;
  }
  ::rs::google::api::PythonSettings* mutable_python_settings() {
    has_python_settings_ = true;
    return &python_settings_;
  }
  ::rs::google::api::NodeSettings* mutable_node_settings() {
    has_node_settings_ = true;
    return &node_settings_;
  }
  ::rs::google::api::DotnetSettings* mutable_dotnet_settings() {
    has_dotnet_settings_ = true;
    return &dotnet_settings_;
  }
  ::rs::google::api::RubySettings* mutable_ruby_settings() {
    has_ruby_settings_ = true;
    return &ruby_settings_;
  }
  ::rs::google::api::GoSettings* mutable_go_settings() {
    has_go_settings_ = true;
    return &go_settings_;
  }
};  // struct ClientLibrarySettings
struct Publishing {
  std::vector< ::rs::google::api::MethodSettings > method_settings_;
  bool has_method_settings_ = false;
  std::string new_issue_uri_;
  bool has_new_issue_uri_ = false;
  std::string documentation_uri_;
  bool has_documentation_uri_ = false;
  std::string api_short_name_;
  bool has_api_short_name_ = false;
  std::string github_label_;
  bool has_github_label_ = false;
  std::vector< std::string > codeowner_github_teams_;
  bool has_codeowner_github_teams_ = false;
  std::string doc_tag_prefix_;
  bool has_doc_tag_prefix_ = false;
  ::rs::google::api::ClientLibraryOrganization organization_ = static_cast< ::rs::google::api::ClientLibraryOrganization >(0);
  bool has_organization_ = false;
  std::vector< ::rs::google::api::ClientLibrarySettings > library_settings_;
  bool has_library_settings_ = false;
  std::string proto_reference_documentation_uri_;
  bool has_proto_reference_documentation_uri_ = false;
  std::string rest_reference_documentation_uri_;
  bool has_rest_reference_documentation_uri_ = false;

  Publishing() = default;
  Publishing(const Publishing&) = default;
  Publishing(Publishing&&) = default;
  Publishing& operator=(const Publishing&) = default;
  Publishing& operator=(Publishing&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::api::MethodSettings >* mutable_method_settings() {
    has_method_settings_ = true;
    return &method_settings_;
  }
  void add_method_settings(const ::rs::google::api::MethodSettings& value);
  std::string* mutable_new_issue_uri() {
    has_new_issue_uri_ = true;
    return &new_issue_uri_;
  }
  void set_new_issue_uri(const std::string& value);
  std::string* mutable_documentation_uri() {
    has_documentation_uri_ = true;
    return &documentation_uri_;
  }
  void set_documentation_uri(const std::string& value);
  std::string* mutable_api_short_name() {
    has_api_short_name_ = true;
    return &api_short_name_;
  }
  void set_api_short_name(const std::string& value);
  std::string* mutable_github_label() {
    has_github_label_ = true;
    return &github_label_;
  }
  void set_github_label(const std::string& value);
  std::vector< std::string >* mutable_codeowner_github_teams() {
    has_codeowner_github_teams_ = true;
    return &codeowner_github_teams_;
  }
  void add_codeowner_github_teams(const std::string& value);
  void set_codeowner_github_teams(const std::vector< std::string >& value);
  std::string* mutable_doc_tag_prefix() {
    has_doc_tag_prefix_ = true;
    return &doc_tag_prefix_;
  }
  void set_doc_tag_prefix(const std::string& value);
  ::rs::google::api::ClientLibraryOrganization* mutable_organization() {
    has_organization_ = true;
    return &organization_;
  }
  void set_organization(const ::rs::google::api::ClientLibraryOrganization& value);
  std::vector< ::rs::google::api::ClientLibrarySettings >* mutable_library_settings() {
    has_library_settings_ = true;
    return &library_settings_;
  }
  void add_library_settings(const ::rs::google::api::ClientLibrarySettings& value);
  std::string* mutable_proto_reference_documentation_uri() {
    has_proto_reference_documentation_uri_ = true;
    return &proto_reference_documentation_uri_;
  }
  void set_proto_reference_documentation_uri(const std::string& value);
  std::string* mutable_rest_reference_documentation_uri() {
    has_rest_reference_documentation_uri_ = true;
    return &rest_reference_documentation_uri_;
  }
  void set_rest_reference_documentation_uri(const std::string& value);
};  // struct Publishing
struct MethodSettings {
  struct LongRunning {
    ::rs::google::protobuf::Duration initial_poll_delay_;
    bool has_initial_poll_delay_ = false;
    float poll_delay_multiplier_ = static_cast< float >(0);
    bool has_poll_delay_multiplier_ = false;
    ::rs::google::protobuf::Duration max_poll_delay_;
    bool has_max_poll_delay_ = false;
    ::rs::google::protobuf::Duration total_poll_timeout_;
    bool has_total_poll_timeout_ = false;

    LongRunning() = default;
    LongRunning(const LongRunning&) = default;
    LongRunning(LongRunning&&) = default;
    LongRunning& operator=(const LongRunning&) = default;
    LongRunning& operator=(LongRunning&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    ::rs::google::protobuf::Duration* mutable_initial_poll_delay() {
      has_initial_poll_delay_ = true;
      return &initial_poll_delay_;
    }
    float* mutable_poll_delay_multiplier() {
      has_poll_delay_multiplier_ = true;
      return &poll_delay_multiplier_;
    }
    void set_poll_delay_multiplier(const float& value);
    ::rs::google::protobuf::Duration* mutable_max_poll_delay() {
      has_max_poll_delay_ = true;
      return &max_poll_delay_;
    }
    ::rs::google::protobuf::Duration* mutable_total_poll_timeout() {
      has_total_poll_timeout_ = true;
      return &total_poll_timeout_;
    }
  };  // struct LongRunning
  std::string selector_;
  bool has_selector_ = false;
  ::rs::google::api::MethodSettings::LongRunning long_running_;
  bool has_long_running_ = false;
  std::vector< std::string > auto_populated_fields_;
  bool has_auto_populated_fields_ = false;

  MethodSettings() = default;
  MethodSettings(const MethodSettings&) = default;
  MethodSettings(MethodSettings&&) = default;
  MethodSettings& operator=(const MethodSettings&) = default;
  MethodSettings& operator=(MethodSettings&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_selector() {
    has_selector_ = true;
    return &selector_;
  }
  void set_selector(const std::string& value);
  ::rs::google::api::MethodSettings::LongRunning* mutable_long_running() {
    has_long_running_ = true;
    return &long_running_;
  }
  std::vector< std::string >* mutable_auto_populated_fields() {
    has_auto_populated_fields_ = true;
    return &auto_populated_fields_;
  }
  void add_auto_populated_fields(const std::string& value);
  void set_auto_populated_fields(const std::vector< std::string >& value);
};  // struct MethodSettings
}  // namespace api
}  // namespace google
namespace google {
namespace api {
enum FieldBehavior {
  FIELD_BEHAVIOR_UNSPECIFIED = 0,
  OPTIONAL = 1,
  REQUIRED = 2,
  OUTPUT_ONLY = 3,
  INPUT_ONLY = 4,
  IMMUTABLE = 5,
  UNORDERED_LIST = 6,
  NON_EMPTY_DEFAULT = 7,
  IDENTIFIER = 8,
};

}  // namespace api
}  // namespace google
namespace google {
namespace api {
struct ResourceDescriptor {
  enum History {
    HISTORY_UNSPECIFIED = 0,
    ORIGINALLY_SINGLE_PATTERN = 1,
    FUTURE_MULTI_PATTERN = 2,
  };

  enum Style {
    STYLE_UNSPECIFIED = 0,
    DECLARATIVE_FRIENDLY = 1,
  };

  std::string type_;
  bool has_type_ = false;
  std::vector< std::string > pattern_;
  bool has_pattern_ = false;
  std::string name_field_;
  bool has_name_field_ = false;
  ::rs::google::api::ResourceDescriptor::History history_ = static_cast< ::rs::google::api::ResourceDescriptor::History >(0);
  bool has_history_ = false;
  std::string plural_;
  bool has_plural_ = false;
  std::string singular_;
  bool has_singular_ = false;
  std::vector< ::rs::google::api::ResourceDescriptor::Style > style_;
  bool has_style_ = false;

  ResourceDescriptor() = default;
  ResourceDescriptor(const ResourceDescriptor&) = default;
  ResourceDescriptor(ResourceDescriptor&&) = default;
  ResourceDescriptor& operator=(const ResourceDescriptor&) = default;
  ResourceDescriptor& operator=(ResourceDescriptor&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_type() {
    has_type_ = true;
    return &type_;
  }
  void set_type(const std::string& value);
  std::vector< std::string >* mutable_pattern() {
    has_pattern_ = true;
    return &pattern_;
  }
  void add_pattern(const std::string& value);
  void set_pattern(const std::vector< std::string >& value);
  std::string* mutable_name_field() {
    has_name_field_ = true;
    return &name_field_;
  }
  void set_name_field(const std::string& value);
  ::rs::google::api::ResourceDescriptor::History* mutable_history() {
    has_history_ = true;
    return &history_;
  }
  void set_history(const ::rs::google::api::ResourceDescriptor::History& value);
  std::string* mutable_plural() {
    has_plural_ = true;
    return &plural_;
  }
  void set_plural(const std::string& value);
  std::string* mutable_singular() {
    has_singular_ = true;
    return &singular_;
  }
  void set_singular(const std::string& value);
  std::vector< ::rs::google::api::ResourceDescriptor::Style >* mutable_style() {
    has_style_ = true;
    return &style_;
  }
  void add_style(const ::rs::google::api::ResourceDescriptor::Style& value);
  void set_style(const std::vector< ::rs::google::api::ResourceDescriptor::Style >& value);
};  // struct ResourceDescriptor
struct ResourceReference {
  std::string type_;
  bool has_type_ = false;
  std::string child_type_;
  bool has_child_type_ = false;

  ResourceReference() = default;
  ResourceReference(const ResourceReference&) = default;
  ResourceReference(ResourceReference&&) = default;
  ResourceReference& operator=(const ResourceReference&) = default;
  ResourceReference& operator=(ResourceReference&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_type() {
    has_type_ = true;
    return &type_;
  }
  void set_type(const std::string& value);
  std::string* mutable_child_type() {
    has_child_type_ = true;
    return &child_type_;
  }
  void set_child_type(const std::string& value);
};  // struct ResourceReference
}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
struct Timestamp {
  int64_t seconds_ = static_cast< int64_t >(0);
  bool has_seconds_ = false;
  int32_t nanos_ = static_cast< int32_t >(0);
  bool has_nanos_ = false;

  Timestamp() = default;
  Timestamp(const Timestamp&) = default;
  Timestamp(Timestamp&&) = default;
  Timestamp& operator=(const Timestamp&) = default;
  Timestamp& operator=(Timestamp&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  int64_t* mutable_seconds() {
    has_seconds_ = true;
    return &seconds_;
  }
  void set_seconds(const int64_t& value);
  int32_t* mutable_nanos() {
    has_nanos_ = true;
    return &nanos_;
  }
  void set_nanos(const int32_t& value);
};  // struct Timestamp
}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
enum Language {
  LANGUAGE_UNSPECIFIED = 0,
  NONE = 1,
  ANDROID = 2,
  AS = 3,
  CC = 4,
  CSS = 5,
  DART = 6,
  GO = 7,
  GWT = 8,
  HASKELL = 9,
  JAVA = 10,
  JS = 11,
  LISP = 12,
  OBJC = 13,
  PY = 14,
  SH = 15,
  SWIFT = 16,
  TS = 18,
  WEB = 19,
  SCALA = 20,
  PROTO = 21,
  XML = 22,
};

enum Status {
  STATUS_UNSPECIFIED = 0,
  BUILDING = 1,
  BUILT = 2,
  FAILED_TO_BUILD = 3,
  TESTING = 4,
  PASSED = 5,
  FAILED = 6,
  TIMED_OUT = 7,
  CANCELLED = 8,
  TOOL_FAILED = 9,
  INCOMPLETE = 10,
  FLAKY = 11,
  UNKNOWN = 12,
  SKIPPED = 13,
};

enum UploadStatus {
  UPLOAD_STATUS_UNSPECIFIED = 0,
  UPLOADING = 1,
  POST_PROCESSING = 2,
  IMMUTABLE = 3,
};

struct StatusAttributes {
  ::rs::google::devtools::resultstore::v2::Status status_ = static_cast< ::rs::google::devtools::resultstore::v2::Status >(0);
  bool has_status_ = false;
  std::string description_;
  bool has_description_ = false;

  StatusAttributes() = default;
  StatusAttributes(const StatusAttributes&) = default;
  StatusAttributes(StatusAttributes&&) = default;
  StatusAttributes& operator=(const StatusAttributes&) = default;
  StatusAttributes& operator=(StatusAttributes&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::Status* mutable_status() {
    has_status_ = true;
    return &status_;
  }
  void set_status(const ::rs::google::devtools::resultstore::v2::Status& value);
  std::string* mutable_description() {
    has_description_ = true;
    return &description_;
  }
  void set_description(const std::string& value);
};  // struct StatusAttributes
struct Property {
  std::string key_;
  bool has_key_ = false;
  std::string value_;
  bool has_value_ = false;

  Property() = default;
  Property(const Property&) = default;
  Property(Property&&) = default;
  Property& operator=(const Property&) = default;
  Property& operator=(Property&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_key() {
    has_key_ = true;
    return &key_;
  }
  void set_key(const std::string& value);
  std::string* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const std::string& value);
};  // struct Property
struct Timing {
  ::rs::google::protobuf::Timestamp start_time_;
  bool has_start_time_ = false;
  ::rs::google::protobuf::Duration duration_;
  bool has_duration_ = false;

  Timing() = default;
  Timing(const Timing&) = default;
  Timing(Timing&&) = default;
  Timing& operator=(const Timing&) = default;
  Timing& operator=(Timing&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::protobuf::Timestamp* mutable_start_time() {
    has_start_time_ = true;
    return &start_time_;
  }
  ::rs::google::protobuf::Duration* mutable_duration() {
    has_duration_ = true;
    return &duration_;
  }
};  // struct Timing
struct Dependency {
  struct Id {
    std::string target_id_;
    bool has_target_id_ = false;
    std::string configuration_id_;
    bool has_configuration_id_ = false;
    std::string action_id_;
    bool has_action_id_ = false;

    Id() = default;
    Id(const Id&) = default;
    Id(Id&&) = default;
    Id& operator=(const Id&) = default;
    Id& operator=(Id&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_target_id() {
      has_target_id_ = true;
      return &target_id_;
    }
    void set_target_id(const std::string& value);
    std::string* mutable_configuration_id() {
      has_configuration_id_ = true;
      return &configuration_id_;
    }
    void set_configuration_id(const std::string& value);
    std::string* mutable_action_id() {
      has_action_id_ = true;
      return &action_id_;
    }
    void set_action_id(const std::string& value);
  };  // struct Id
  std::string target_;
  bool has_target_ = false;
  std::string configured_target_;
  bool has_configured_target_ = false;
  std::string action_;
  bool has_action_ = false;
  ::rs::google::devtools::resultstore::v2::Dependency::Id id_;
  bool has_id_ = false;
  std::string label_;
  bool has_label_ = false;

  Dependency() = default;
  Dependency(const Dependency&) = default;
  Dependency(Dependency&&) = default;
  Dependency& operator=(const Dependency&) = default;
  Dependency& operator=(Dependency&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_target() {
    has_target_ = true;
    return &target_;
  }
  void set_target(const std::string& value);
  std::string* mutable_configured_target() {
    has_configured_target_ = true;
    return &configured_target_;
  }
  void set_configured_target(const std::string& value);
  std::string* mutable_action() {
    has_action_ = true;
    return &action_;
  }
  void set_action(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Dependency::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
  std::string* mutable_label() {
    has_label_ = true;
    return &label_;
  }
  void set_label(const std::string& value);
};  // struct Dependency
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct LineCoverage {
  std::string instrumented_lines_;
  bool has_instrumented_lines_ = false;
  std::string executed_lines_;
  bool has_executed_lines_ = false;

  LineCoverage() = default;
  LineCoverage(const LineCoverage&) = default;
  LineCoverage(LineCoverage&&) = default;
  LineCoverage& operator=(const LineCoverage&) = default;
  LineCoverage& operator=(LineCoverage&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_instrumented_lines() {
    has_instrumented_lines_ = true;
    return &instrumented_lines_;
  }
  void set_instrumented_lines(const std::string& value);
  std::string* mutable_executed_lines() {
    has_executed_lines_ = true;
    return &executed_lines_;
  }
  void set_executed_lines(const std::string& value);
};  // struct LineCoverage
struct BranchCoverage {
  std::string branch_present_;
  bool has_branch_present_ = false;
  std::vector< int32_t > branches_in_line_;
  bool has_branches_in_line_ = false;
  std::string executed_;
  bool has_executed_ = false;
  std::string taken_;
  bool has_taken_ = false;

  BranchCoverage() = default;
  BranchCoverage(const BranchCoverage&) = default;
  BranchCoverage(BranchCoverage&&) = default;
  BranchCoverage& operator=(const BranchCoverage&) = default;
  BranchCoverage& operator=(BranchCoverage&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_branch_present() {
    has_branch_present_ = true;
    return &branch_present_;
  }
  void set_branch_present(const std::string& value);
  std::vector< int32_t >* mutable_branches_in_line() {
    has_branches_in_line_ = true;
    return &branches_in_line_;
  }
  void add_branches_in_line(const int32_t& value);
  void set_branches_in_line(const std::vector< int32_t >& value);
  std::string* mutable_executed() {
    has_executed_ = true;
    return &executed_;
  }
  void set_executed(const std::string& value);
  std::string* mutable_taken() {
    has_taken_ = true;
    return &taken_;
  }
  void set_taken(const std::string& value);
};  // struct BranchCoverage
struct FileCoverage {
  std::string path_;
  bool has_path_ = false;
  ::rs::google::devtools::resultstore::v2::LineCoverage line_coverage_;
  bool has_line_coverage_ = false;
  ::rs::google::devtools::resultstore::v2::BranchCoverage branch_coverage_;
  bool has_branch_coverage_ = false;

  FileCoverage() = default;
  FileCoverage(const FileCoverage&) = default;
  FileCoverage(FileCoverage&&) = default;
  FileCoverage& operator=(const FileCoverage&) = default;
  FileCoverage& operator=(FileCoverage&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_path() {
    has_path_ = true;
    return &path_;
  }
  void set_path(const std::string& value);
  ::rs::google::devtools::resultstore::v2::LineCoverage* mutable_line_coverage() {
    has_line_coverage_ = true;
    return &line_coverage_;
  }
  ::rs::google::devtools::resultstore::v2::BranchCoverage* mutable_branch_coverage() {
    has_branch_coverage_ = true;
    return &branch_coverage_;
  }
};  // struct FileCoverage
struct ActionCoverage {
  std::vector< ::rs::google::devtools::resultstore::v2::FileCoverage > file_coverages_;
  bool has_file_coverages_ = false;

  ActionCoverage() = default;
  ActionCoverage(const ActionCoverage&) = default;
  ActionCoverage(ActionCoverage&&) = default;
  ActionCoverage& operator=(const ActionCoverage&) = default;
  ActionCoverage& operator=(ActionCoverage&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::devtools::resultstore::v2::FileCoverage >* mutable_file_coverages() {
    has_file_coverages_ = true;
    return &file_coverages_;
  }
  void add_file_coverages(const ::rs::google::devtools::resultstore::v2::FileCoverage& value);
};  // struct ActionCoverage
struct AggregateCoverage {
  std::vector< ::rs::google::devtools::resultstore::v2::FileCoverage > file_coverages_;
  bool has_file_coverages_ = false;

  AggregateCoverage() = default;
  AggregateCoverage(const AggregateCoverage&) = default;
  AggregateCoverage(AggregateCoverage&&) = default;
  AggregateCoverage& operator=(const AggregateCoverage&) = default;
  AggregateCoverage& operator=(AggregateCoverage&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::rs::google::devtools::resultstore::v2::FileCoverage >* mutable_file_coverages() {
    has_file_coverages_ = true;
    return &file_coverages_;
  }
  void add_file_coverages(const ::rs::google::devtools::resultstore::v2::FileCoverage& value);
};  // struct AggregateCoverage
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace protobuf {
struct DoubleValue {
  double value_ = static_cast< double >(0);
  bool has_value_ = false;

  DoubleValue() = default;
  DoubleValue(const DoubleValue&) = default;
  DoubleValue(DoubleValue&&) = default;
  DoubleValue& operator=(const DoubleValue&) = default;
  DoubleValue& operator=(DoubleValue&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  double* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const double& value);
};  // struct DoubleValue
struct FloatValue {
  float value_ = static_cast< float >(0);
  bool has_value_ = false;

  FloatValue() = default;
  FloatValue(const FloatValue&) = default;
  FloatValue(FloatValue&&) = default;
  FloatValue& operator=(const FloatValue&) = default;
  FloatValue& operator=(FloatValue&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  float* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const float& value);
};  // struct FloatValue
struct Int64Value {
  int64_t value_ = static_cast< int64_t >(0);
  bool has_value_ = false;

  Int64Value() = default;
  Int64Value(const Int64Value&) = default;
  Int64Value(Int64Value&&) = default;
  Int64Value& operator=(const Int64Value&) = default;
  Int64Value& operator=(Int64Value&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  int64_t* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const int64_t& value);
};  // struct Int64Value
struct UInt64Value {
  uint64_t value_ = static_cast< uint64_t >(0);
  bool has_value_ = false;

  UInt64Value() = default;
  UInt64Value(const UInt64Value&) = default;
  UInt64Value(UInt64Value&&) = default;
  UInt64Value& operator=(const UInt64Value&) = default;
  UInt64Value& operator=(UInt64Value&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  uint64_t* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const uint64_t& value);
};  // struct UInt64Value
struct Int32Value {
  int32_t value_ = static_cast< int32_t >(0);
  bool has_value_ = false;

  Int32Value() = default;
  Int32Value(const Int32Value&) = default;
  Int32Value(Int32Value&&) = default;
  Int32Value& operator=(const Int32Value&) = default;
  Int32Value& operator=(Int32Value&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  int32_t* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const int32_t& value);
};  // struct Int32Value
struct UInt32Value {
  uint32_t value_ = static_cast< uint32_t >(0);
  bool has_value_ = false;

  UInt32Value() = default;
  UInt32Value(const UInt32Value&) = default;
  UInt32Value(UInt32Value&&) = default;
  UInt32Value& operator=(const UInt32Value&) = default;
  UInt32Value& operator=(UInt32Value&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  uint32_t* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const uint32_t& value);
};  // struct UInt32Value
struct BoolValue {
  bool value_ = false;
  bool has_value_ = false;

  BoolValue() = default;
  BoolValue(const BoolValue&) = default;
  BoolValue(BoolValue&&) = default;
  BoolValue& operator=(const BoolValue&) = default;
  BoolValue& operator=(BoolValue&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const bool& value);
};  // struct BoolValue
struct StringValue {
  std::string value_;
  bool has_value_ = false;

  StringValue() = default;
  StringValue(const StringValue&) = default;
  StringValue(StringValue&&) = default;
  StringValue& operator=(const StringValue&) = default;
  StringValue& operator=(StringValue&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const std::string& value);
};  // struct StringValue
struct BytesValue {
  std::string value_;
  bool has_value_ = false;

  BytesValue() = default;
  BytesValue(const BytesValue&) = default;
  BytesValue(BytesValue&&) = default;
  BytesValue& operator=(const BytesValue&) = default;
  BytesValue& operator=(BytesValue&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const std::string& value);
};  // struct BytesValue
}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct ArchiveEntry {
  std::string path_;
  bool has_path_ = false;
  ::rs::google::protobuf::Int64Value length_;
  bool has_length_ = false;
  std::string content_type_;
  bool has_content_type_ = false;

  ArchiveEntry() = default;
  ArchiveEntry(const ArchiveEntry&) = default;
  ArchiveEntry(ArchiveEntry&&) = default;
  ArchiveEntry& operator=(const ArchiveEntry&) = default;
  ArchiveEntry& operator=(ArchiveEntry&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_path() {
    has_path_ = true;
    return &path_;
  }
  void set_path(const std::string& value);
  ::rs::google::protobuf::Int64Value* mutable_length() {
    has_length_ = true;
    return &length_;
  }
  std::string* mutable_content_type() {
    has_content_type_ = true;
    return &content_type_;
  }
  void set_content_type(const std::string& value);
};  // struct ArchiveEntry
struct File {
  enum HashType {
    HASH_TYPE_UNSPECIFIED = 0,
    MD5 = 1,
    SHA1 = 2,
    SHA256 = 3,
  };

  std::string uid_;
  bool has_uid_ = false;
  std::string uri_;
  bool has_uri_ = false;
  ::rs::google::protobuf::Int64Value length_;
  bool has_length_ = false;
  std::string content_type_;
  bool has_content_type_ = false;
  ::rs::google::devtools::resultstore::v2::ArchiveEntry archive_entry_;
  bool has_archive_entry_ = false;
  std::string content_viewer_;
  bool has_content_viewer_ = false;
  bool hidden_ = false;
  bool has_hidden_ = false;
  std::string description_;
  bool has_description_ = false;
  std::string digest_;
  bool has_digest_ = false;
  ::rs::google::devtools::resultstore::v2::File::HashType hash_type_ = static_cast< ::rs::google::devtools::resultstore::v2::File::HashType >(0);
  bool has_hash_type_ = false;

  File() = default;
  File(const File&) = default;
  File(File&&) = default;
  File& operator=(const File&) = default;
  File& operator=(File&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_uid() {
    has_uid_ = true;
    return &uid_;
  }
  void set_uid(const std::string& value);
  std::string* mutable_uri() {
    has_uri_ = true;
    return &uri_;
  }
  void set_uri(const std::string& value);
  ::rs::google::protobuf::Int64Value* mutable_length() {
    has_length_ = true;
    return &length_;
  }
  std::string* mutable_content_type() {
    has_content_type_ = true;
    return &content_type_;
  }
  void set_content_type(const std::string& value);
  ::rs::google::devtools::resultstore::v2::ArchiveEntry* mutable_archive_entry() {
    has_archive_entry_ = true;
    return &archive_entry_;
  }
  std::string* mutable_content_viewer() {
    has_content_viewer_ = true;
    return &content_viewer_;
  }
  void set_content_viewer(const std::string& value);
  bool* mutable_hidden() {
    has_hidden_ = true;
    return &hidden_;
  }
  void set_hidden(const bool& value);
  std::string* mutable_description() {
    has_description_ = true;
    return &description_;
  }
  void set_description(const std::string& value);
  std::string* mutable_digest() {
    has_digest_ = true;
    return &digest_;
  }
  void set_digest(const std::string& value);
  ::rs::google::devtools::resultstore::v2::File::HashType* mutable_hash_type() {
    has_hash_type_ = true;
    return &hash_type_;
  }
  void set_hash_type(const ::rs::google::devtools::resultstore::v2::File::HashType& value);
};  // struct File
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
enum FileProcessingErrorType {
  FILE_PROCESSING_ERROR_TYPE_UNSPECIFIED = 0,
  GENERIC_READ_ERROR = 1,
  GENERIC_PARSE_ERROR = 2,
  FILE_TOO_LARGE = 3,
  OUTPUT_TOO_LARGE = 4,
  ACCESS_DENIED = 5,
  DEADLINE_EXCEEDED = 6,
  NOT_FOUND = 7,
  FILE_EMPTY = 8,
};

struct FileProcessingErrors {
  std::string file_uid_;
  bool has_file_uid_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::FileProcessingError > file_processing_errors_;
  bool has_file_processing_errors_ = false;

  FileProcessingErrors() = default;
  FileProcessingErrors(const FileProcessingErrors&) = default;
  FileProcessingErrors(FileProcessingErrors&&) = default;
  FileProcessingErrors& operator=(const FileProcessingErrors&) = default;
  FileProcessingErrors& operator=(FileProcessingErrors&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_file_uid() {
    has_file_uid_ = true;
    return &file_uid_;
  }
  void set_file_uid(const std::string& value);
  std::vector< ::rs::google::devtools::resultstore::v2::FileProcessingError >* mutable_file_processing_errors() {
    has_file_processing_errors_ = true;
    return &file_processing_errors_;
  }
  void add_file_processing_errors(const ::rs::google::devtools::resultstore::v2::FileProcessingError& value);
};  // struct FileProcessingErrors
struct FileProcessingError {
  ::rs::google::devtools::resultstore::v2::FileProcessingErrorType type_ = static_cast< ::rs::google::devtools::resultstore::v2::FileProcessingErrorType >(0);
  bool has_type_ = false;
  std::string message_;
  bool has_message_ = false;

  FileProcessingError() = default;
  FileProcessingError(const FileProcessingError&) = default;
  FileProcessingError(FileProcessingError&&) = default;
  FileProcessingError& operator=(const FileProcessingError&) = default;
  FileProcessingError& operator=(FileProcessingError&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::FileProcessingErrorType* mutable_type() {
    has_type_ = true;
    return &type_;
  }
  void set_type(const ::rs::google::devtools::resultstore::v2::FileProcessingErrorType& value);
  std::string* mutable_message() {
    has_message_ = true;
    return &message_;
  }
  void set_message(const std::string& value);
};  // struct FileProcessingError
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct TestSuite {
  std::string suite_name_;
  bool has_suite_name_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::Test > tests_;
  bool has_tests_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::TestFailure > failures_;
  bool has_failures_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::TestError > errors_;
  bool has_errors_ = false;
  ::rs::google::devtools::resultstore::v2::Timing timing_;
  bool has_timing_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::Property > properties_;
  bool has_properties_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::File > files_;
  bool has_files_ = false;

  TestSuite() = default;
  TestSuite(const TestSuite&) = default;
  TestSuite(TestSuite&&) = default;
  TestSuite& operator=(const TestSuite&) = default;
  TestSuite& operator=(TestSuite&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_suite_name() {
    has_suite_name_ = true;
    return &suite_name_;
  }
  void set_suite_name(const std::string& value);
  std::vector< ::rs::google::devtools::resultstore::v2::Test >* mutable_tests() {
    has_tests_ = true;
    return &tests_;
  }
  void add_tests(const ::rs::google::devtools::resultstore::v2::Test& value);
  std::vector< ::rs::google::devtools::resultstore::v2::TestFailure >* mutable_failures() {
    has_failures_ = true;
    return &failures_;
  }
  void add_failures(const ::rs::google::devtools::resultstore::v2::TestFailure& value);
  std::vector< ::rs::google::devtools::resultstore::v2::TestError >* mutable_errors() {
    has_errors_ = true;
    return &errors_;
  }
  void add_errors(const ::rs::google::devtools::resultstore::v2::TestError& value);
  ::rs::google::devtools::resultstore::v2::Timing* mutable_timing() {
    has_timing_ = true;
    return &timing_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::Property >* mutable_properties() {
    has_properties_ = true;
    return &properties_;
  }
  void add_properties(const ::rs::google::devtools::resultstore::v2::Property& value);
  std::vector< ::rs::google::devtools::resultstore::v2::File >* mutable_files() {
    has_files_ = true;
    return &files_;
  }
  void add_files(const ::rs::google::devtools::resultstore::v2::File& value);
};  // struct TestSuite
struct TestCase {
  enum Result {
    RESULT_UNSPECIFIED = 0,
    COMPLETED = 1,
    INTERRUPTED = 2,
    CANCELLED = 3,
    FILTERED = 4,
    SKIPPED = 5,
    SUPPRESSED = 6,
  };

  std::string case_name_;
  bool has_case_name_ = false;
  std::string class_name_;
  bool has_class_name_ = false;
  ::rs::google::devtools::resultstore::v2::TestCase::Result result_ = static_cast< ::rs::google::devtools::resultstore::v2::TestCase::Result >(0);
  bool has_result_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::TestFailure > failures_;
  bool has_failures_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::TestError > errors_;
  bool has_errors_ = false;
  ::rs::google::devtools::resultstore::v2::Timing timing_;
  bool has_timing_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::Property > properties_;
  bool has_properties_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::File > files_;
  bool has_files_ = false;
  int32_t retry_number_ = static_cast< int32_t >(0);
  bool has_retry_number_ = false;
  int32_t repeat_number_ = static_cast< int32_t >(0);
  bool has_repeat_number_ = false;

  TestCase() = default;
  TestCase(const TestCase&) = default;
  TestCase(TestCase&&) = default;
  TestCase& operator=(const TestCase&) = default;
  TestCase& operator=(TestCase&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_case_name() {
    has_case_name_ = true;
    return &case_name_;
  }
  void set_case_name(const std::string& value);
  std::string* mutable_class_name() {
    has_class_name_ = true;
    return &class_name_;
  }
  void set_class_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::TestCase::Result* mutable_result() {
    has_result_ = true;
    return &result_;
  }
  void set_result(const ::rs::google::devtools::resultstore::v2::TestCase::Result& value);
  std::vector< ::rs::google::devtools::resultstore::v2::TestFailure >* mutable_failures() {
    has_failures_ = true;
    return &failures_;
  }
  void add_failures(const ::rs::google::devtools::resultstore::v2::TestFailure& value);
  std::vector< ::rs::google::devtools::resultstore::v2::TestError >* mutable_errors() {
    has_errors_ = true;
    return &errors_;
  }
  void add_errors(const ::rs::google::devtools::resultstore::v2::TestError& value);
  ::rs::google::devtools::resultstore::v2::Timing* mutable_timing() {
    has_timing_ = true;
    return &timing_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::Property >* mutable_properties() {
    has_properties_ = true;
    return &properties_;
  }
  void add_properties(const ::rs::google::devtools::resultstore::v2::Property& value);
  std::vector< ::rs::google::devtools::resultstore::v2::File >* mutable_files() {
    has_files_ = true;
    return &files_;
  }
  void add_files(const ::rs::google::devtools::resultstore::v2::File& value);
  int32_t* mutable_retry_number() {
    has_retry_number_ = true;
    return &retry_number_;
  }
  void set_retry_number(const int32_t& value);
  int32_t* mutable_repeat_number() {
    has_repeat_number_ = true;
    return &repeat_number_;
  }
  void set_repeat_number(const int32_t& value);
};  // struct TestCase
struct Test {
  ::rs::google::devtools::resultstore::v2::TestCase test_case_;
  bool has_test_case_ = false;
  ::rs::google::devtools::resultstore::v2::TestSuite test_suite_;
  bool has_test_suite_ = false;

  Test() = default;
  Test(const Test&) = default;
  Test(Test&&) = default;
  Test& operator=(const Test&) = default;
  Test& operator=(Test&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::TestCase* mutable_test_case() {
    has_test_case_ = true;
    return &test_case_;
  }
  ::rs::google::devtools::resultstore::v2::TestSuite* mutable_test_suite() {
    has_test_suite_ = true;
    return &test_suite_;
  }
};  // struct Test
struct TestFailure {
  std::string failure_message_;
  bool has_failure_message_ = false;
  std::string exception_type_;
  bool has_exception_type_ = false;
  std::string stack_trace_;
  bool has_stack_trace_ = false;
  std::vector< std::string > expected_;
  bool has_expected_ = false;
  std::vector< std::string > actual_;
  bool has_actual_ = false;

  TestFailure() = default;
  TestFailure(const TestFailure&) = default;
  TestFailure(TestFailure&&) = default;
  TestFailure& operator=(const TestFailure&) = default;
  TestFailure& operator=(TestFailure&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_failure_message() {
    has_failure_message_ = true;
    return &failure_message_;
  }
  void set_failure_message(const std::string& value);
  std::string* mutable_exception_type() {
    has_exception_type_ = true;
    return &exception_type_;
  }
  void set_exception_type(const std::string& value);
  std::string* mutable_stack_trace() {
    has_stack_trace_ = true;
    return &stack_trace_;
  }
  void set_stack_trace(const std::string& value);
  std::vector< std::string >* mutable_expected() {
    has_expected_ = true;
    return &expected_;
  }
  void add_expected(const std::string& value);
  void set_expected(const std::vector< std::string >& value);
  std::vector< std::string >* mutable_actual() {
    has_actual_ = true;
    return &actual_;
  }
  void add_actual(const std::string& value);
  void set_actual(const std::vector< std::string >& value);
};  // struct TestFailure
struct TestError {
  std::string error_message_;
  bool has_error_message_ = false;
  std::string exception_type_;
  bool has_exception_type_ = false;
  std::string stack_trace_;
  bool has_stack_trace_ = false;

  TestError() = default;
  TestError(const TestError&) = default;
  TestError(TestError&&) = default;
  TestError& operator=(const TestError&) = default;
  TestError& operator=(TestError&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_error_message() {
    has_error_message_ = true;
    return &error_message_;
  }
  void set_error_message(const std::string& value);
  std::string* mutable_exception_type() {
    has_exception_type_ = true;
    return &exception_type_;
  }
  void set_exception_type(const std::string& value);
  std::string* mutable_stack_trace() {
    has_stack_trace_ = true;
    return &stack_trace_;
  }
  void set_stack_trace(const std::string& value);
};  // struct TestError
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
enum ExecutionStrategy {
  EXECUTION_STRATEGY_UNSPECIFIED = 0,
  OTHER_ENVIRONMENT = 1,
  REMOTE_SERVICE = 2,
  LOCAL_PARALLEL = 3,
  LOCAL_SEQUENTIAL = 4,
};

enum TestCaching {
  TEST_CACHING_UNSPECIFIED = 0,
  LOCAL_CACHE_HIT = 1,
  REMOTE_CACHE_HIT = 2,
  CACHE_MISS = 3,
};

struct InputFileInfo {
  int64_t count_ = static_cast< int64_t >(0);
  bool has_count_ = false;
  int64_t distinct_count_ = static_cast< int64_t >(0);
  bool has_distinct_count_ = false;
  int64_t count_limit_ = static_cast< int64_t >(0);
  bool has_count_limit_ = false;
  int64_t distinct_bytes_ = static_cast< int64_t >(0);
  bool has_distinct_bytes_ = false;
  int64_t distinct_byte_limit_ = static_cast< int64_t >(0);
  bool has_distinct_byte_limit_ = false;

  InputFileInfo() = default;
  InputFileInfo(const InputFileInfo&) = default;
  InputFileInfo(InputFileInfo&&) = default;
  InputFileInfo& operator=(const InputFileInfo&) = default;
  InputFileInfo& operator=(InputFileInfo&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  int64_t* mutable_count() {
    has_count_ = true;
    return &count_;
  }
  void set_count(const int64_t& value);
  int64_t* mutable_distinct_count() {
    has_distinct_count_ = true;
    return &distinct_count_;
  }
  void set_distinct_count(const int64_t& value);
  int64_t* mutable_count_limit() {
    has_count_limit_ = true;
    return &count_limit_;
  }
  void set_count_limit(const int64_t& value);
  int64_t* mutable_distinct_bytes() {
    has_distinct_bytes_ = true;
    return &distinct_bytes_;
  }
  void set_distinct_bytes(const int64_t& value);
  int64_t* mutable_distinct_byte_limit() {
    has_distinct_byte_limit_ = true;
    return &distinct_byte_limit_;
  }
  void set_distinct_byte_limit(const int64_t& value);
};  // struct InputFileInfo
struct ActionAttributes {
  ::rs::google::devtools::resultstore::v2::ExecutionStrategy execution_strategy_ = static_cast< ::rs::google::devtools::resultstore::v2::ExecutionStrategy >(0);
  bool has_execution_strategy_ = false;
  int32_t exit_code_ = static_cast< int32_t >(0);
  bool has_exit_code_ = false;
  std::string hostname_;
  bool has_hostname_ = false;
  ::rs::google::devtools::resultstore::v2::InputFileInfo input_file_info_;
  bool has_input_file_info_ = false;

  ActionAttributes() = default;
  ActionAttributes(const ActionAttributes&) = default;
  ActionAttributes(ActionAttributes&&) = default;
  ActionAttributes& operator=(const ActionAttributes&) = default;
  ActionAttributes& operator=(ActionAttributes&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::ExecutionStrategy* mutable_execution_strategy() {
    has_execution_strategy_ = true;
    return &execution_strategy_;
  }
  void set_execution_strategy(const ::rs::google::devtools::resultstore::v2::ExecutionStrategy& value);
  int32_t* mutable_exit_code() {
    has_exit_code_ = true;
    return &exit_code_;
  }
  void set_exit_code(const int32_t& value);
  std::string* mutable_hostname() {
    has_hostname_ = true;
    return &hostname_;
  }
  void set_hostname(const std::string& value);
  ::rs::google::devtools::resultstore::v2::InputFileInfo* mutable_input_file_info() {
    has_input_file_info_ = true;
    return &input_file_info_;
  }
};  // struct ActionAttributes
struct BuildAction {
  std::string type_;
  bool has_type_ = false;
  std::string primary_input_path_;
  bool has_primary_input_path_ = false;
  std::string primary_output_path_;
  bool has_primary_output_path_ = false;

  BuildAction() = default;
  BuildAction(const BuildAction&) = default;
  BuildAction(BuildAction&&) = default;
  BuildAction& operator=(const BuildAction&) = default;
  BuildAction& operator=(BuildAction&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_type() {
    has_type_ = true;
    return &type_;
  }
  void set_type(const std::string& value);
  std::string* mutable_primary_input_path() {
    has_primary_input_path_ = true;
    return &primary_input_path_;
  }
  void set_primary_input_path(const std::string& value);
  std::string* mutable_primary_output_path() {
    has_primary_output_path_ = true;
    return &primary_output_path_;
  }
  void set_primary_output_path(const std::string& value);
};  // struct BuildAction
struct LocalTestTiming {
  ::rs::google::protobuf::Duration test_process_duration_;
  bool has_test_process_duration_ = false;

  LocalTestTiming() = default;
  LocalTestTiming(const LocalTestTiming&) = default;
  LocalTestTiming(LocalTestTiming&&) = default;
  LocalTestTiming& operator=(const LocalTestTiming&) = default;
  LocalTestTiming& operator=(LocalTestTiming&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::protobuf::Duration* mutable_test_process_duration() {
    has_test_process_duration_ = true;
    return &test_process_duration_;
  }
};  // struct LocalTestTiming
struct RemoteTestTiming {
  ::rs::google::protobuf::Duration local_analysis_duration_;
  bool has_local_analysis_duration_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::RemoteTestAttemptTiming > attempts_;
  bool has_attempts_ = false;

  RemoteTestTiming() = default;
  RemoteTestTiming(const RemoteTestTiming&) = default;
  RemoteTestTiming(RemoteTestTiming&&) = default;
  RemoteTestTiming& operator=(const RemoteTestTiming&) = default;
  RemoteTestTiming& operator=(RemoteTestTiming&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::protobuf::Duration* mutable_local_analysis_duration() {
    has_local_analysis_duration_ = true;
    return &local_analysis_duration_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::RemoteTestAttemptTiming >* mutable_attempts() {
    has_attempts_ = true;
    return &attempts_;
  }
  void add_attempts(const ::rs::google::devtools::resultstore::v2::RemoteTestAttemptTiming& value);
};  // struct RemoteTestTiming
struct TestTiming {
  ::rs::google::devtools::resultstore::v2::LocalTestTiming local_;
  bool has_local_ = false;
  ::rs::google::devtools::resultstore::v2::RemoteTestTiming remote_;
  bool has_remote_ = false;
  ::rs::google::protobuf::Duration system_time_duration_;
  bool has_system_time_duration_ = false;
  ::rs::google::protobuf::Duration user_time_duration_;
  bool has_user_time_duration_ = false;
  ::rs::google::devtools::resultstore::v2::TestCaching test_caching_ = static_cast< ::rs::google::devtools::resultstore::v2::TestCaching >(0);
  bool has_test_caching_ = false;

  TestTiming() = default;
  TestTiming(const TestTiming&) = default;
  TestTiming(TestTiming&&) = default;
  TestTiming& operator=(const TestTiming&) = default;
  TestTiming& operator=(TestTiming&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::LocalTestTiming* mutable_local() {
    has_local_ = true;
    return &local_;
  }
  ::rs::google::devtools::resultstore::v2::RemoteTestTiming* mutable_remote() {
    has_remote_ = true;
    return &remote_;
  }
  ::rs::google::protobuf::Duration* mutable_system_time_duration() {
    has_system_time_duration_ = true;
    return &system_time_duration_;
  }
  ::rs::google::protobuf::Duration* mutable_user_time_duration() {
    has_user_time_duration_ = true;
    return &user_time_duration_;
  }
  ::rs::google::devtools::resultstore::v2::TestCaching* mutable_test_caching() {
    has_test_caching_ = true;
    return &test_caching_;
  }
  void set_test_caching(const ::rs::google::devtools::resultstore::v2::TestCaching& value);
};  // struct TestTiming
struct TestAction {
  ::rs::google::devtools::resultstore::v2::TestTiming test_timing_;
  bool has_test_timing_ = false;
  int32_t shard_number_ = static_cast< int32_t >(0);
  bool has_shard_number_ = false;
  int32_t run_number_ = static_cast< int32_t >(0);
  bool has_run_number_ = false;
  int32_t attempt_number_ = static_cast< int32_t >(0);
  bool has_attempt_number_ = false;
  ::rs::google::devtools::resultstore::v2::TestSuite test_suite_;
  bool has_test_suite_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::TestWarning > warnings_;
  bool has_warnings_ = false;
  int64_t estimated_memory_bytes_ = static_cast< int64_t >(0);
  bool has_estimated_memory_bytes_ = false;

  TestAction() = default;
  TestAction(const TestAction&) = default;
  TestAction(TestAction&&) = default;
  TestAction& operator=(const TestAction&) = default;
  TestAction& operator=(TestAction&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::TestTiming* mutable_test_timing() {
    has_test_timing_ = true;
    return &test_timing_;
  }
  int32_t* mutable_shard_number() {
    has_shard_number_ = true;
    return &shard_number_;
  }
  void set_shard_number(const int32_t& value);
  int32_t* mutable_run_number() {
    has_run_number_ = true;
    return &run_number_;
  }
  void set_run_number(const int32_t& value);
  int32_t* mutable_attempt_number() {
    has_attempt_number_ = true;
    return &attempt_number_;
  }
  void set_attempt_number(const int32_t& value);
  ::rs::google::devtools::resultstore::v2::TestSuite* mutable_test_suite() {
    has_test_suite_ = true;
    return &test_suite_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::TestWarning >* mutable_warnings() {
    has_warnings_ = true;
    return &warnings_;
  }
  void add_warnings(const ::rs::google::devtools::resultstore::v2::TestWarning& value);
  int64_t* mutable_estimated_memory_bytes() {
    has_estimated_memory_bytes_ = true;
    return &estimated_memory_bytes_;
  }
  void set_estimated_memory_bytes(const int64_t& value);
};  // struct TestAction
struct Action {
  struct Id {
    std::string invocation_id_;
    bool has_invocation_id_ = false;
    std::string target_id_;
    bool has_target_id_ = false;
    std::string configuration_id_;
    bool has_configuration_id_ = false;
    std::string action_id_;
    bool has_action_id_ = false;

    Id() = default;
    Id(const Id&) = default;
    Id(Id&&) = default;
    Id& operator=(const Id&) = default;
    Id& operator=(Id&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_invocation_id() {
      has_invocation_id_ = true;
      return &invocation_id_;
    }
    void set_invocation_id(const std::string& value);
    std::string* mutable_target_id() {
      has_target_id_ = true;
      return &target_id_;
    }
    void set_target_id(const std::string& value);
    std::string* mutable_configuration_id() {
      has_configuration_id_ = true;
      return &configuration_id_;
    }
    void set_configuration_id(const std::string& value);
    std::string* mutable_action_id() {
      has_action_id_ = true;
      return &action_id_;
    }
    void set_action_id(const std::string& value);
  };  // struct Id
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::Action::Id id_;
  bool has_id_ = false;
  ::rs::google::devtools::resultstore::v2::StatusAttributes status_attributes_;
  bool has_status_attributes_ = false;
  ::rs::google::devtools::resultstore::v2::Timing timing_;
  bool has_timing_ = false;
  ::rs::google::devtools::resultstore::v2::BuildAction build_action_;
  bool has_build_action_ = false;
  ::rs::google::devtools::resultstore::v2::TestAction test_action_;
  bool has_test_action_ = false;
  ::rs::google::devtools::resultstore::v2::ActionAttributes action_attributes_;
  bool has_action_attributes_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::Dependency > action_dependencies_;
  bool has_action_dependencies_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::Property > properties_;
  bool has_properties_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::File > files_;
  bool has_files_ = false;
  std::vector< std::string > file_sets_;
  bool has_file_sets_ = false;
  ::rs::google::devtools::resultstore::v2::ActionCoverage coverage_;
  bool has_coverage_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::FileProcessingErrors > file_processing_errors_;
  bool has_file_processing_errors_ = false;

  Action() = default;
  Action(const Action&) = default;
  Action(Action&&) = default;
  Action& operator=(const Action&) = default;
  Action& operator=(Action&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Action::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
  ::rs::google::devtools::resultstore::v2::StatusAttributes* mutable_status_attributes() {
    has_status_attributes_ = true;
    return &status_attributes_;
  }
  ::rs::google::devtools::resultstore::v2::Timing* mutable_timing() {
    has_timing_ = true;
    return &timing_;
  }
  ::rs::google::devtools::resultstore::v2::BuildAction* mutable_build_action() {
    has_build_action_ = true;
    return &build_action_;
  }
  ::rs::google::devtools::resultstore::v2::TestAction* mutable_test_action() {
    has_test_action_ = true;
    return &test_action_;
  }
  ::rs::google::devtools::resultstore::v2::ActionAttributes* mutable_action_attributes() {
    has_action_attributes_ = true;
    return &action_attributes_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::Dependency >* mutable_action_dependencies() {
    has_action_dependencies_ = true;
    return &action_dependencies_;
  }
  void add_action_dependencies(const ::rs::google::devtools::resultstore::v2::Dependency& value);
  std::vector< ::rs::google::devtools::resultstore::v2::Property >* mutable_properties() {
    has_properties_ = true;
    return &properties_;
  }
  void add_properties(const ::rs::google::devtools::resultstore::v2::Property& value);
  std::vector< ::rs::google::devtools::resultstore::v2::File >* mutable_files() {
    has_files_ = true;
    return &files_;
  }
  void add_files(const ::rs::google::devtools::resultstore::v2::File& value);
  std::vector< std::string >* mutable_file_sets() {
    has_file_sets_ = true;
    return &file_sets_;
  }
  void add_file_sets(const std::string& value);
  void set_file_sets(const std::vector< std::string >& value);
  ::rs::google::devtools::resultstore::v2::ActionCoverage* mutable_coverage() {
    has_coverage_ = true;
    return &coverage_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::FileProcessingErrors >* mutable_file_processing_errors() {
    has_file_processing_errors_ = true;
    return &file_processing_errors_;
  }
  void add_file_processing_errors(const ::rs::google::devtools::resultstore::v2::FileProcessingErrors& value);
};  // struct Action
struct RemoteTestAttemptTiming {
  ::rs::google::protobuf::Duration queue_duration_;
  bool has_queue_duration_ = false;
  ::rs::google::protobuf::Duration upload_duration_;
  bool has_upload_duration_ = false;
  ::rs::google::protobuf::Duration machine_setup_duration_;
  bool has_machine_setup_duration_ = false;
  ::rs::google::protobuf::Duration test_process_duration_;
  bool has_test_process_duration_ = false;
  ::rs::google::protobuf::Duration download_duration_;
  bool has_download_duration_ = false;

  RemoteTestAttemptTiming() = default;
  RemoteTestAttemptTiming(const RemoteTestAttemptTiming&) = default;
  RemoteTestAttemptTiming(RemoteTestAttemptTiming&&) = default;
  RemoteTestAttemptTiming& operator=(const RemoteTestAttemptTiming&) = default;
  RemoteTestAttemptTiming& operator=(RemoteTestAttemptTiming&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::protobuf::Duration* mutable_queue_duration() {
    has_queue_duration_ = true;
    return &queue_duration_;
  }
  ::rs::google::protobuf::Duration* mutable_upload_duration() {
    has_upload_duration_ = true;
    return &upload_duration_;
  }
  ::rs::google::protobuf::Duration* mutable_machine_setup_duration() {
    has_machine_setup_duration_ = true;
    return &machine_setup_duration_;
  }
  ::rs::google::protobuf::Duration* mutable_test_process_duration() {
    has_test_process_duration_ = true;
    return &test_process_duration_;
  }
  ::rs::google::protobuf::Duration* mutable_download_duration() {
    has_download_duration_ = true;
    return &download_duration_;
  }
};  // struct RemoteTestAttemptTiming
struct TestWarning {
  std::string warning_message_;
  bool has_warning_message_ = false;

  TestWarning() = default;
  TestWarning(const TestWarning&) = default;
  TestWarning(TestWarning&&) = default;
  TestWarning& operator=(const TestWarning&) = default;
  TestWarning& operator=(TestWarning&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_warning_message() {
    has_warning_message_ = true;
    return &warning_message_;
  }
  void set_warning_message(const std::string& value);
};  // struct TestWarning
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct ConfigurationAttributes {
  std::string cpu_;
  bool has_cpu_ = false;

  ConfigurationAttributes() = default;
  ConfigurationAttributes(const ConfigurationAttributes&) = default;
  ConfigurationAttributes(ConfigurationAttributes&&) = default;
  ConfigurationAttributes& operator=(const ConfigurationAttributes&) = default;
  ConfigurationAttributes& operator=(ConfigurationAttributes&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_cpu() {
    has_cpu_ = true;
    return &cpu_;
  }
  void set_cpu(const std::string& value);
};  // struct ConfigurationAttributes
struct Configuration {
  struct Id {
    std::string invocation_id_;
    bool has_invocation_id_ = false;
    std::string configuration_id_;
    bool has_configuration_id_ = false;

    Id() = default;
    Id(const Id&) = default;
    Id(Id&&) = default;
    Id& operator=(const Id&) = default;
    Id& operator=(Id&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_invocation_id() {
      has_invocation_id_ = true;
      return &invocation_id_;
    }
    void set_invocation_id(const std::string& value);
    std::string* mutable_configuration_id() {
      has_configuration_id_ = true;
      return &configuration_id_;
    }
    void set_configuration_id(const std::string& value);
  };  // struct Id
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::Configuration::Id id_;
  bool has_id_ = false;
  ::rs::google::devtools::resultstore::v2::StatusAttributes status_attributes_;
  bool has_status_attributes_ = false;
  ::rs::google::devtools::resultstore::v2::ConfigurationAttributes configuration_attributes_;
  bool has_configuration_attributes_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::Property > properties_;
  bool has_properties_ = false;
  std::string display_name_;
  bool has_display_name_ = false;

  Configuration() = default;
  Configuration(const Configuration&) = default;
  Configuration(Configuration&&) = default;
  Configuration& operator=(const Configuration&) = default;
  Configuration& operator=(Configuration&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Configuration::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
  ::rs::google::devtools::resultstore::v2::StatusAttributes* mutable_status_attributes() {
    has_status_attributes_ = true;
    return &status_attributes_;
  }
  ::rs::google::devtools::resultstore::v2::ConfigurationAttributes* mutable_configuration_attributes() {
    has_configuration_attributes_ = true;
    return &configuration_attributes_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::Property >* mutable_properties() {
    has_properties_ = true;
    return &properties_;
  }
  void add_properties(const ::rs::google::devtools::resultstore::v2::Property& value);
  std::string* mutable_display_name() {
    has_display_name_ = true;
    return &display_name_;
  }
  void set_display_name(const std::string& value);
};  // struct Configuration
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct ConfiguredTestAttributes {
  int32_t total_run_count_ = static_cast< int32_t >(0);
  bool has_total_run_count_ = false;
  int32_t total_shard_count_ = static_cast< int32_t >(0);
  bool has_total_shard_count_ = false;
  ::rs::google::protobuf::Duration timeout_duration_;
  bool has_timeout_duration_ = false;

  ConfiguredTestAttributes() = default;
  ConfiguredTestAttributes(const ConfiguredTestAttributes&) = default;
  ConfiguredTestAttributes(ConfiguredTestAttributes&&) = default;
  ConfiguredTestAttributes& operator=(const ConfiguredTestAttributes&) = default;
  ConfiguredTestAttributes& operator=(ConfiguredTestAttributes&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  int32_t* mutable_total_run_count() {
    has_total_run_count_ = true;
    return &total_run_count_;
  }
  void set_total_run_count(const int32_t& value);
  int32_t* mutable_total_shard_count() {
    has_total_shard_count_ = true;
    return &total_shard_count_;
  }
  void set_total_shard_count(const int32_t& value);
  ::rs::google::protobuf::Duration* mutable_timeout_duration() {
    has_timeout_duration_ = true;
    return &timeout_duration_;
  }
};  // struct ConfiguredTestAttributes
struct ConfiguredTarget {
  struct Id {
    std::string invocation_id_;
    bool has_invocation_id_ = false;
    std::string target_id_;
    bool has_target_id_ = false;
    std::string configuration_id_;
    bool has_configuration_id_ = false;

    Id() = default;
    Id(const Id&) = default;
    Id(Id&&) = default;
    Id& operator=(const Id&) = default;
    Id& operator=(Id&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_invocation_id() {
      has_invocation_id_ = true;
      return &invocation_id_;
    }
    void set_invocation_id(const std::string& value);
    std::string* mutable_target_id() {
      has_target_id_ = true;
      return &target_id_;
    }
    void set_target_id(const std::string& value);
    std::string* mutable_configuration_id() {
      has_configuration_id_ = true;
      return &configuration_id_;
    }
    void set_configuration_id(const std::string& value);
  };  // struct Id
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget::Id id_;
  bool has_id_ = false;
  ::rs::google::devtools::resultstore::v2::StatusAttributes status_attributes_;
  bool has_status_attributes_ = false;
  ::rs::google::devtools::resultstore::v2::Timing timing_;
  bool has_timing_ = false;
  ::rs::google::devtools::resultstore::v2::ConfiguredTestAttributes test_attributes_;
  bool has_test_attributes_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::Property > properties_;
  bool has_properties_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::File > files_;
  bool has_files_ = false;

  ConfiguredTarget() = default;
  ConfiguredTarget(const ConfiguredTarget&) = default;
  ConfiguredTarget(ConfiguredTarget&&) = default;
  ConfiguredTarget& operator=(const ConfiguredTarget&) = default;
  ConfiguredTarget& operator=(ConfiguredTarget&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
  ::rs::google::devtools::resultstore::v2::StatusAttributes* mutable_status_attributes() {
    has_status_attributes_ = true;
    return &status_attributes_;
  }
  ::rs::google::devtools::resultstore::v2::Timing* mutable_timing() {
    has_timing_ = true;
    return &timing_;
  }
  ::rs::google::devtools::resultstore::v2::ConfiguredTestAttributes* mutable_test_attributes() {
    has_test_attributes_ = true;
    return &test_attributes_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::Property >* mutable_properties() {
    has_properties_ = true;
    return &properties_;
  }
  void add_properties(const ::rs::google::devtools::resultstore::v2::Property& value);
  std::vector< ::rs::google::devtools::resultstore::v2::File >* mutable_files() {
    has_files_ = true;
    return &files_;
  }
  void add_files(const ::rs::google::devtools::resultstore::v2::File& value);
};  // struct ConfiguredTarget
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct FileSet {
  struct Id {
    std::string invocation_id_;
    bool has_invocation_id_ = false;
    std::string file_set_id_;
    bool has_file_set_id_ = false;

    Id() = default;
    Id(const Id&) = default;
    Id(Id&&) = default;
    Id& operator=(const Id&) = default;
    Id& operator=(Id&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_invocation_id() {
      has_invocation_id_ = true;
      return &invocation_id_;
    }
    void set_invocation_id(const std::string& value);
    std::string* mutable_file_set_id() {
      has_file_set_id_ = true;
      return &file_set_id_;
    }
    void set_file_set_id(const std::string& value);
  };  // struct Id
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::FileSet::Id id_;
  bool has_id_ = false;
  std::vector< std::string > file_sets_;
  bool has_file_sets_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::File > files_;
  bool has_files_ = false;

  FileSet() = default;
  FileSet(const FileSet&) = default;
  FileSet(FileSet&&) = default;
  FileSet& operator=(const FileSet&) = default;
  FileSet& operator=(FileSet&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::FileSet::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
  std::vector< std::string >* mutable_file_sets() {
    has_file_sets_ = true;
    return &file_sets_;
  }
  void add_file_sets(const std::string& value);
  void set_file_sets(const std::vector< std::string >& value);
  std::vector< ::rs::google::devtools::resultstore::v2::File >* mutable_files() {
    has_files_ = true;
    return &files_;
  }
  void add_files(const ::rs::google::devtools::resultstore::v2::File& value);
};  // struct FileSet
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct LineCoverageSummary {
  int32_t instrumented_line_count_ = static_cast< int32_t >(0);
  bool has_instrumented_line_count_ = false;
  int32_t executed_line_count_ = static_cast< int32_t >(0);
  bool has_executed_line_count_ = false;

  LineCoverageSummary() = default;
  LineCoverageSummary(const LineCoverageSummary&) = default;
  LineCoverageSummary(LineCoverageSummary&&) = default;
  LineCoverageSummary& operator=(const LineCoverageSummary&) = default;
  LineCoverageSummary& operator=(LineCoverageSummary&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  int32_t* mutable_instrumented_line_count() {
    has_instrumented_line_count_ = true;
    return &instrumented_line_count_;
  }
  void set_instrumented_line_count(const int32_t& value);
  int32_t* mutable_executed_line_count() {
    has_executed_line_count_ = true;
    return &executed_line_count_;
  }
  void set_executed_line_count(const int32_t& value);
};  // struct LineCoverageSummary
struct BranchCoverageSummary {
  int32_t total_branch_count_ = static_cast< int32_t >(0);
  bool has_total_branch_count_ = false;
  int32_t executed_branch_count_ = static_cast< int32_t >(0);
  bool has_executed_branch_count_ = false;
  int32_t taken_branch_count_ = static_cast< int32_t >(0);
  bool has_taken_branch_count_ = false;

  BranchCoverageSummary() = default;
  BranchCoverageSummary(const BranchCoverageSummary&) = default;
  BranchCoverageSummary(BranchCoverageSummary&&) = default;
  BranchCoverageSummary& operator=(const BranchCoverageSummary&) = default;
  BranchCoverageSummary& operator=(BranchCoverageSummary&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  int32_t* mutable_total_branch_count() {
    has_total_branch_count_ = true;
    return &total_branch_count_;
  }
  void set_total_branch_count(const int32_t& value);
  int32_t* mutable_executed_branch_count() {
    has_executed_branch_count_ = true;
    return &executed_branch_count_;
  }
  void set_executed_branch_count(const int32_t& value);
  int32_t* mutable_taken_branch_count() {
    has_taken_branch_count_ = true;
    return &taken_branch_count_;
  }
  void set_taken_branch_count(const int32_t& value);
};  // struct BranchCoverageSummary
struct LanguageCoverageSummary {
  ::rs::google::devtools::resultstore::v2::Language language_ = static_cast< ::rs::google::devtools::resultstore::v2::Language >(0);
  bool has_language_ = false;
  ::rs::google::devtools::resultstore::v2::LineCoverageSummary line_summary_;
  bool has_line_summary_ = false;
  ::rs::google::devtools::resultstore::v2::BranchCoverageSummary branch_summary_;
  bool has_branch_summary_ = false;

  LanguageCoverageSummary() = default;
  LanguageCoverageSummary(const LanguageCoverageSummary&) = default;
  LanguageCoverageSummary(LanguageCoverageSummary&&) = default;
  LanguageCoverageSummary& operator=(const LanguageCoverageSummary&) = default;
  LanguageCoverageSummary& operator=(LanguageCoverageSummary&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::Language* mutable_language() {
    has_language_ = true;
    return &language_;
  }
  void set_language(const ::rs::google::devtools::resultstore::v2::Language& value);
  ::rs::google::devtools::resultstore::v2::LineCoverageSummary* mutable_line_summary() {
    has_line_summary_ = true;
    return &line_summary_;
  }
  ::rs::google::devtools::resultstore::v2::BranchCoverageSummary* mutable_branch_summary() {
    has_branch_summary_ = true;
    return &branch_summary_;
  }
};  // struct LanguageCoverageSummary
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct InvocationAttributes {
  std::string project_id_;
  bool has_project_id_ = false;
  std::vector< std::string > users_;
  bool has_users_ = false;
  std::vector< std::string > labels_;
  bool has_labels_ = false;
  std::string description_;
  bool has_description_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::InvocationContext > invocation_contexts_;
  bool has_invocation_contexts_ = false;
  int32_t exit_code_ = static_cast< int32_t >(0);
  bool has_exit_code_ = false;

  InvocationAttributes() = default;
  InvocationAttributes(const InvocationAttributes&) = default;
  InvocationAttributes(InvocationAttributes&&) = default;
  InvocationAttributes& operator=(const InvocationAttributes&) = default;
  InvocationAttributes& operator=(InvocationAttributes&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_project_id() {
    has_project_id_ = true;
    return &project_id_;
  }
  void set_project_id(const std::string& value);
  std::vector< std::string >* mutable_users() {
    has_users_ = true;
    return &users_;
  }
  void add_users(const std::string& value);
  void set_users(const std::vector< std::string >& value);
  std::vector< std::string >* mutable_labels() {
    has_labels_ = true;
    return &labels_;
  }
  void add_labels(const std::string& value);
  void set_labels(const std::vector< std::string >& value);
  std::string* mutable_description() {
    has_description_ = true;
    return &description_;
  }
  void set_description(const std::string& value);
  std::vector< ::rs::google::devtools::resultstore::v2::InvocationContext >* mutable_invocation_contexts() {
    has_invocation_contexts_ = true;
    return &invocation_contexts_;
  }
  void add_invocation_contexts(const ::rs::google::devtools::resultstore::v2::InvocationContext& value);
  int32_t* mutable_exit_code() {
    has_exit_code_ = true;
    return &exit_code_;
  }
  void set_exit_code(const int32_t& value);
};  // struct InvocationAttributes
struct WorkspaceContext {
  WorkspaceContext() = default;
  WorkspaceContext(const WorkspaceContext&) = default;
  WorkspaceContext(WorkspaceContext&&) = default;
  WorkspaceContext& operator=(const WorkspaceContext&) = default;
  WorkspaceContext& operator=(WorkspaceContext&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
};  // struct WorkspaceContext
struct WorkspaceInfo {
  ::rs::google::devtools::resultstore::v2::WorkspaceContext workspace_context_;
  bool has_workspace_context_ = false;
  std::string hostname_;
  bool has_hostname_ = false;
  std::string working_directory_;
  bool has_working_directory_ = false;
  std::string tool_tag_;
  bool has_tool_tag_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::CommandLine > command_lines_;
  bool has_command_lines_ = false;

  WorkspaceInfo() = default;
  WorkspaceInfo(const WorkspaceInfo&) = default;
  WorkspaceInfo(WorkspaceInfo&&) = default;
  WorkspaceInfo& operator=(const WorkspaceInfo&) = default;
  WorkspaceInfo& operator=(WorkspaceInfo&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::WorkspaceContext* mutable_workspace_context() {
    has_workspace_context_ = true;
    return &workspace_context_;
  }
  std::string* mutable_hostname() {
    has_hostname_ = true;
    return &hostname_;
  }
  void set_hostname(const std::string& value);
  std::string* mutable_working_directory() {
    has_working_directory_ = true;
    return &working_directory_;
  }
  void set_working_directory(const std::string& value);
  std::string* mutable_tool_tag() {
    has_tool_tag_ = true;
    return &tool_tag_;
  }
  void set_tool_tag(const std::string& value);
  std::vector< ::rs::google::devtools::resultstore::v2::CommandLine >* mutable_command_lines() {
    has_command_lines_ = true;
    return &command_lines_;
  }
  void add_command_lines(const ::rs::google::devtools::resultstore::v2::CommandLine& value);
};  // struct WorkspaceInfo
struct Invocation {
  struct Id {
    std::string invocation_id_;
    bool has_invocation_id_ = false;

    Id() = default;
    Id(const Id&) = default;
    Id(Id&&) = default;
    Id& operator=(const Id&) = default;
    Id& operator=(Id&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_invocation_id() {
      has_invocation_id_ = true;
      return &invocation_id_;
    }
    void set_invocation_id(const std::string& value);
  };  // struct Id
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::Invocation::Id id_;
  bool has_id_ = false;
  ::rs::google::devtools::resultstore::v2::StatusAttributes status_attributes_;
  bool has_status_attributes_ = false;
  ::rs::google::devtools::resultstore::v2::Timing timing_;
  bool has_timing_ = false;
  ::rs::google::devtools::resultstore::v2::InvocationAttributes invocation_attributes_;
  bool has_invocation_attributes_ = false;
  ::rs::google::devtools::resultstore::v2::WorkspaceInfo workspace_info_;
  bool has_workspace_info_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::Property > properties_;
  bool has_properties_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::File > files_;
  bool has_files_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::LanguageCoverageSummary > coverage_summaries_;
  bool has_coverage_summaries_ = false;
  ::rs::google::devtools::resultstore::v2::AggregateCoverage aggregate_coverage_;
  bool has_aggregate_coverage_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::FileProcessingErrors > file_processing_errors_;
  bool has_file_processing_errors_ = false;

  Invocation() = default;
  Invocation(const Invocation&) = default;
  Invocation(Invocation&&) = default;
  Invocation& operator=(const Invocation&) = default;
  Invocation& operator=(Invocation&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Invocation::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
  ::rs::google::devtools::resultstore::v2::StatusAttributes* mutable_status_attributes() {
    has_status_attributes_ = true;
    return &status_attributes_;
  }
  ::rs::google::devtools::resultstore::v2::Timing* mutable_timing() {
    has_timing_ = true;
    return &timing_;
  }
  ::rs::google::devtools::resultstore::v2::InvocationAttributes* mutable_invocation_attributes() {
    has_invocation_attributes_ = true;
    return &invocation_attributes_;
  }
  ::rs::google::devtools::resultstore::v2::WorkspaceInfo* mutable_workspace_info() {
    has_workspace_info_ = true;
    return &workspace_info_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::Property >* mutable_properties() {
    has_properties_ = true;
    return &properties_;
  }
  void add_properties(const ::rs::google::devtools::resultstore::v2::Property& value);
  std::vector< ::rs::google::devtools::resultstore::v2::File >* mutable_files() {
    has_files_ = true;
    return &files_;
  }
  void add_files(const ::rs::google::devtools::resultstore::v2::File& value);
  std::vector< ::rs::google::devtools::resultstore::v2::LanguageCoverageSummary >* mutable_coverage_summaries() {
    has_coverage_summaries_ = true;
    return &coverage_summaries_;
  }
  void add_coverage_summaries(const ::rs::google::devtools::resultstore::v2::LanguageCoverageSummary& value);
  ::rs::google::devtools::resultstore::v2::AggregateCoverage* mutable_aggregate_coverage() {
    has_aggregate_coverage_ = true;
    return &aggregate_coverage_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::FileProcessingErrors >* mutable_file_processing_errors() {
    has_file_processing_errors_ = true;
    return &file_processing_errors_;
  }
  void add_file_processing_errors(const ::rs::google::devtools::resultstore::v2::FileProcessingErrors& value);
};  // struct Invocation
struct CommandLine {
  std::string label_;
  bool has_label_ = false;
  std::string tool_;
  bool has_tool_ = false;
  std::vector< std::string > args_;
  bool has_args_ = false;
  std::string command_;
  bool has_command_ = false;

  CommandLine() = default;
  CommandLine(const CommandLine&) = default;
  CommandLine(CommandLine&&) = default;
  CommandLine& operator=(const CommandLine&) = default;
  CommandLine& operator=(CommandLine&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_label() {
    has_label_ = true;
    return &label_;
  }
  void set_label(const std::string& value);
  std::string* mutable_tool() {
    has_tool_ = true;
    return &tool_;
  }
  void set_tool(const std::string& value);
  std::vector< std::string >* mutable_args() {
    has_args_ = true;
    return &args_;
  }
  void add_args(const std::string& value);
  void set_args(const std::vector< std::string >& value);
  std::string* mutable_command() {
    has_command_ = true;
    return &command_;
  }
  void set_command(const std::string& value);
};  // struct CommandLine
struct InvocationContext {
  std::string display_name_;
  bool has_display_name_ = false;
  std::string url_;
  bool has_url_ = false;

  InvocationContext() = default;
  InvocationContext(const InvocationContext&) = default;
  InvocationContext(InvocationContext&&) = default;
  InvocationContext& operator=(const InvocationContext&) = default;
  InvocationContext& operator=(InvocationContext&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_display_name() {
    has_display_name_ = true;
    return &display_name_;
  }
  void set_display_name(const std::string& value);
  std::string* mutable_url() {
    has_url_ = true;
    return &url_;
  }
  void set_url(const std::string& value);
};  // struct InvocationContext
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
enum TargetType {
  TARGET_TYPE_UNSPECIFIED = 0,
  APPLICATION = 1,
  BINARY = 2,
  LIBRARY = 3,
  PACKAGE = 4,
  TEST = 5,
};

enum TestSize {
  TEST_SIZE_UNSPECIFIED = 0,
  SMALL = 1,
  MEDIUM = 2,
  LARGE = 3,
  ENORMOUS = 4,
  OTHER_SIZE = 5,
};

struct TargetAttributes {
  ::rs::google::devtools::resultstore::v2::TargetType type_ = static_cast< ::rs::google::devtools::resultstore::v2::TargetType >(0);
  bool has_type_ = false;
  ::rs::google::devtools::resultstore::v2::Language language_ = static_cast< ::rs::google::devtools::resultstore::v2::Language >(0);
  bool has_language_ = false;
  std::vector< std::string > tags_;
  bool has_tags_ = false;

  TargetAttributes() = default;
  TargetAttributes(const TargetAttributes&) = default;
  TargetAttributes(TargetAttributes&&) = default;
  TargetAttributes& operator=(const TargetAttributes&) = default;
  TargetAttributes& operator=(TargetAttributes&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::TargetType* mutable_type() {
    has_type_ = true;
    return &type_;
  }
  void set_type(const ::rs::google::devtools::resultstore::v2::TargetType& value);
  ::rs::google::devtools::resultstore::v2::Language* mutable_language() {
    has_language_ = true;
    return &language_;
  }
  void set_language(const ::rs::google::devtools::resultstore::v2::Language& value);
  std::vector< std::string >* mutable_tags() {
    has_tags_ = true;
    return &tags_;
  }
  void add_tags(const std::string& value);
  void set_tags(const std::vector< std::string >& value);
};  // struct TargetAttributes
struct TestAttributes {
  ::rs::google::devtools::resultstore::v2::TestSize size_ = static_cast< ::rs::google::devtools::resultstore::v2::TestSize >(0);
  bool has_size_ = false;

  TestAttributes() = default;
  TestAttributes(const TestAttributes&) = default;
  TestAttributes(TestAttributes&&) = default;
  TestAttributes& operator=(const TestAttributes&) = default;
  TestAttributes& operator=(TestAttributes&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::TestSize* mutable_size() {
    has_size_ = true;
    return &size_;
  }
  void set_size(const ::rs::google::devtools::resultstore::v2::TestSize& value);
};  // struct TestAttributes
struct Target {
  struct Id {
    std::string invocation_id_;
    bool has_invocation_id_ = false;
    std::string target_id_;
    bool has_target_id_ = false;

    Id() = default;
    Id(const Id&) = default;
    Id(Id&&) = default;
    Id& operator=(const Id&) = default;
    Id& operator=(Id&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_invocation_id() {
      has_invocation_id_ = true;
      return &invocation_id_;
    }
    void set_invocation_id(const std::string& value);
    std::string* mutable_target_id() {
      has_target_id_ = true;
      return &target_id_;
    }
    void set_target_id(const std::string& value);
  };  // struct Id
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::Target::Id id_;
  bool has_id_ = false;
  ::rs::google::devtools::resultstore::v2::StatusAttributes status_attributes_;
  bool has_status_attributes_ = false;
  ::rs::google::devtools::resultstore::v2::Timing timing_;
  bool has_timing_ = false;
  ::rs::google::devtools::resultstore::v2::TargetAttributes target_attributes_;
  bool has_target_attributes_ = false;
  ::rs::google::devtools::resultstore::v2::TestAttributes test_attributes_;
  bool has_test_attributes_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::Property > properties_;
  bool has_properties_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::File > files_;
  bool has_files_ = false;
  bool visible_ = false;
  bool has_visible_ = false;

  Target() = default;
  Target(const Target&) = default;
  Target(Target&&) = default;
  Target& operator=(const Target&) = default;
  Target& operator=(Target&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Target::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
  ::rs::google::devtools::resultstore::v2::StatusAttributes* mutable_status_attributes() {
    has_status_attributes_ = true;
    return &status_attributes_;
  }
  ::rs::google::devtools::resultstore::v2::Timing* mutable_timing() {
    has_timing_ = true;
    return &timing_;
  }
  ::rs::google::devtools::resultstore::v2::TargetAttributes* mutable_target_attributes() {
    has_target_attributes_ = true;
    return &target_attributes_;
  }
  ::rs::google::devtools::resultstore::v2::TestAttributes* mutable_test_attributes() {
    has_test_attributes_ = true;
    return &test_attributes_;
  }
  std::vector< ::rs::google::devtools::resultstore::v2::Property >* mutable_properties() {
    has_properties_ = true;
    return &properties_;
  }
  void add_properties(const ::rs::google::devtools::resultstore::v2::Property& value);
  std::vector< ::rs::google::devtools::resultstore::v2::File >* mutable_files() {
    has_files_ = true;
    return &files_;
  }
  void add_files(const ::rs::google::devtools::resultstore::v2::File& value);
  bool* mutable_visible() {
    has_visible_ = true;
    return &visible_;
  }
  void set_visible(const bool& value);
};  // struct Target
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct UploadMetadata {
  std::string name_;
  bool has_name_ = false;
  std::string resume_token_;
  bool has_resume_token_ = false;
  std::string uploader_state_;
  bool has_uploader_state_ = false;

  UploadMetadata() = default;
  UploadMetadata(const UploadMetadata&) = default;
  UploadMetadata(UploadMetadata&&) = default;
  UploadMetadata& operator=(const UploadMetadata&) = default;
  UploadMetadata& operator=(UploadMetadata&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::string* mutable_resume_token() {
    has_resume_token_ = true;
    return &resume_token_;
  }
  void set_resume_token(const std::string& value);
  std::string* mutable_uploader_state() {
    has_uploader_state_ = true;
    return &uploader_state_;
  }
  void set_uploader_state(const std::string& value);
};  // struct UploadMetadata
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace protobuf {
struct Empty {
  Empty() = default;
  Empty(const Empty&) = default;
  Empty(Empty&&) = default;
  Empty& operator=(const Empty&) = default;
  Empty& operator=(Empty&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
};  // struct Empty
}  // namespace protobuf
}  // namespace google
namespace google {
namespace protobuf {
struct FieldMask {
  std::vector< std::string > paths_;
  bool has_paths_ = false;

  FieldMask() = default;
  FieldMask(const FieldMask&) = default;
  FieldMask(FieldMask&&) = default;
  FieldMask& operator=(const FieldMask&) = default;
  FieldMask& operator=(FieldMask&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< std::string >* mutable_paths() {
    has_paths_ = true;
    return &paths_;
  }
  void add_paths(const std::string& value);
  void set_paths(const std::vector< std::string >& value);
};  // struct FieldMask
}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
struct CreateInvocationRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  std::string invocation_id_;
  bool has_invocation_id_ = false;
  ::rs::google::devtools::resultstore::v2::Invocation invocation_;
  bool has_invocation_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  ::rs::google::protobuf::Timestamp auto_finalize_time_;
  bool has_auto_finalize_time_ = false;
  std::string initial_resume_token_;
  bool has_initial_resume_token_ = false;
  std::string uploader_state_;
  bool has_uploader_state_ = false;

  CreateInvocationRequest() = default;
  CreateInvocationRequest(const CreateInvocationRequest&) = default;
  CreateInvocationRequest(CreateInvocationRequest&&) = default;
  CreateInvocationRequest& operator=(const CreateInvocationRequest&) = default;
  CreateInvocationRequest& operator=(CreateInvocationRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  std::string* mutable_invocation_id() {
    has_invocation_id_ = true;
    return &invocation_id_;
  }
  void set_invocation_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Invocation* mutable_invocation() {
    has_invocation_ = true;
    return &invocation_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  ::rs::google::protobuf::Timestamp* mutable_auto_finalize_time() {
    has_auto_finalize_time_ = true;
    return &auto_finalize_time_;
  }
  std::string* mutable_initial_resume_token() {
    has_initial_resume_token_ = true;
    return &initial_resume_token_;
  }
  void set_initial_resume_token(const std::string& value);
  std::string* mutable_uploader_state() {
    has_uploader_state_ = true;
    return &uploader_state_;
  }
  void set_uploader_state(const std::string& value);
};  // struct CreateInvocationRequest
struct UpdateInvocationRequest {
  ::rs::google::devtools::resultstore::v2::Invocation invocation_;
  bool has_invocation_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  UpdateInvocationRequest() = default;
  UpdateInvocationRequest(const UpdateInvocationRequest&) = default;
  UpdateInvocationRequest(UpdateInvocationRequest&&) = default;
  UpdateInvocationRequest& operator=(const UpdateInvocationRequest&) = default;
  UpdateInvocationRequest& operator=(UpdateInvocationRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::Invocation* mutable_invocation() {
    has_invocation_ = true;
    return &invocation_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct UpdateInvocationRequest
struct MergeInvocationRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  ::rs::google::devtools::resultstore::v2::Invocation invocation_;
  bool has_invocation_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  MergeInvocationRequest() = default;
  MergeInvocationRequest(const MergeInvocationRequest&) = default;
  MergeInvocationRequest(MergeInvocationRequest&&) = default;
  MergeInvocationRequest& operator=(const MergeInvocationRequest&) = default;
  MergeInvocationRequest& operator=(MergeInvocationRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Invocation* mutable_invocation() {
    has_invocation_ = true;
    return &invocation_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct MergeInvocationRequest
struct TouchInvocationRequest {
  std::string name_;
  bool has_name_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  TouchInvocationRequest() = default;
  TouchInvocationRequest(const TouchInvocationRequest&) = default;
  TouchInvocationRequest(TouchInvocationRequest&&) = default;
  TouchInvocationRequest& operator=(const TouchInvocationRequest&) = default;
  TouchInvocationRequest& operator=(TouchInvocationRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct TouchInvocationRequest
struct TouchInvocationResponse {
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::Invocation::Id id_;
  bool has_id_ = false;

  TouchInvocationResponse() = default;
  TouchInvocationResponse(const TouchInvocationResponse&) = default;
  TouchInvocationResponse(TouchInvocationResponse&&) = default;
  TouchInvocationResponse& operator=(const TouchInvocationResponse&) = default;
  TouchInvocationResponse& operator=(TouchInvocationResponse&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Invocation::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
};  // struct TouchInvocationResponse
struct DeleteInvocationRequest {
  std::string name_;
  bool has_name_ = false;

  DeleteInvocationRequest() = default;
  DeleteInvocationRequest(const DeleteInvocationRequest&) = default;
  DeleteInvocationRequest(DeleteInvocationRequest&&) = default;
  DeleteInvocationRequest& operator=(const DeleteInvocationRequest&) = default;
  DeleteInvocationRequest& operator=(DeleteInvocationRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
};  // struct DeleteInvocationRequest
struct FinalizeInvocationRequest {
  std::string name_;
  bool has_name_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  FinalizeInvocationRequest() = default;
  FinalizeInvocationRequest(const FinalizeInvocationRequest&) = default;
  FinalizeInvocationRequest(FinalizeInvocationRequest&&) = default;
  FinalizeInvocationRequest& operator=(const FinalizeInvocationRequest&) = default;
  FinalizeInvocationRequest& operator=(FinalizeInvocationRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct FinalizeInvocationRequest
struct FinalizeInvocationResponse {
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::Invocation::Id id_;
  bool has_id_ = false;

  FinalizeInvocationResponse() = default;
  FinalizeInvocationResponse(const FinalizeInvocationResponse&) = default;
  FinalizeInvocationResponse(FinalizeInvocationResponse&&) = default;
  FinalizeInvocationResponse& operator=(const FinalizeInvocationResponse&) = default;
  FinalizeInvocationResponse& operator=(FinalizeInvocationResponse&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Invocation::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
};  // struct FinalizeInvocationResponse
struct CreateTargetRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  std::string parent_;
  bool has_parent_ = false;
  std::string target_id_;
  bool has_target_id_ = false;
  ::rs::google::devtools::resultstore::v2::Target target_;
  bool has_target_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  CreateTargetRequest() = default;
  CreateTargetRequest(const CreateTargetRequest&) = default;
  CreateTargetRequest(CreateTargetRequest&&) = default;
  CreateTargetRequest& operator=(const CreateTargetRequest&) = default;
  CreateTargetRequest& operator=(CreateTargetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  std::string* mutable_parent() {
    has_parent_ = true;
    return &parent_;
  }
  void set_parent(const std::string& value);
  std::string* mutable_target_id() {
    has_target_id_ = true;
    return &target_id_;
  }
  void set_target_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Target* mutable_target() {
    has_target_ = true;
    return &target_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct CreateTargetRequest
struct UpdateTargetRequest {
  ::rs::google::devtools::resultstore::v2::Target target_;
  bool has_target_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;

  UpdateTargetRequest() = default;
  UpdateTargetRequest(const UpdateTargetRequest&) = default;
  UpdateTargetRequest(UpdateTargetRequest&&) = default;
  UpdateTargetRequest& operator=(const UpdateTargetRequest&) = default;
  UpdateTargetRequest& operator=(UpdateTargetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::Target* mutable_target() {
    has_target_ = true;
    return &target_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
};  // struct UpdateTargetRequest
struct MergeTargetRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  ::rs::google::devtools::resultstore::v2::Target target_;
  bool has_target_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;

  MergeTargetRequest() = default;
  MergeTargetRequest(const MergeTargetRequest&) = default;
  MergeTargetRequest(MergeTargetRequest&&) = default;
  MergeTargetRequest& operator=(const MergeTargetRequest&) = default;
  MergeTargetRequest& operator=(MergeTargetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Target* mutable_target() {
    has_target_ = true;
    return &target_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
};  // struct MergeTargetRequest
struct FinalizeTargetRequest {
  std::string name_;
  bool has_name_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  FinalizeTargetRequest() = default;
  FinalizeTargetRequest(const FinalizeTargetRequest&) = default;
  FinalizeTargetRequest(FinalizeTargetRequest&&) = default;
  FinalizeTargetRequest& operator=(const FinalizeTargetRequest&) = default;
  FinalizeTargetRequest& operator=(FinalizeTargetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct FinalizeTargetRequest
struct FinalizeTargetResponse {
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::Target::Id id_;
  bool has_id_ = false;

  FinalizeTargetResponse() = default;
  FinalizeTargetResponse(const FinalizeTargetResponse&) = default;
  FinalizeTargetResponse(FinalizeTargetResponse&&) = default;
  FinalizeTargetResponse& operator=(const FinalizeTargetResponse&) = default;
  FinalizeTargetResponse& operator=(FinalizeTargetResponse&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Target::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
};  // struct FinalizeTargetResponse
struct CreateConfiguredTargetRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  std::string parent_;
  bool has_parent_ = false;
  std::string config_id_;
  bool has_config_id_ = false;
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget configured_target_;
  bool has_configured_target_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  CreateConfiguredTargetRequest() = default;
  CreateConfiguredTargetRequest(const CreateConfiguredTargetRequest&) = default;
  CreateConfiguredTargetRequest(CreateConfiguredTargetRequest&&) = default;
  CreateConfiguredTargetRequest& operator=(const CreateConfiguredTargetRequest&) = default;
  CreateConfiguredTargetRequest& operator=(CreateConfiguredTargetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  std::string* mutable_parent() {
    has_parent_ = true;
    return &parent_;
  }
  void set_parent(const std::string& value);
  std::string* mutable_config_id() {
    has_config_id_ = true;
    return &config_id_;
  }
  void set_config_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget* mutable_configured_target() {
    has_configured_target_ = true;
    return &configured_target_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct CreateConfiguredTargetRequest
struct UpdateConfiguredTargetRequest {
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget configured_target_;
  bool has_configured_target_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;

  UpdateConfiguredTargetRequest() = default;
  UpdateConfiguredTargetRequest(const UpdateConfiguredTargetRequest&) = default;
  UpdateConfiguredTargetRequest(UpdateConfiguredTargetRequest&&) = default;
  UpdateConfiguredTargetRequest& operator=(const UpdateConfiguredTargetRequest&) = default;
  UpdateConfiguredTargetRequest& operator=(UpdateConfiguredTargetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget* mutable_configured_target() {
    has_configured_target_ = true;
    return &configured_target_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
};  // struct UpdateConfiguredTargetRequest
struct MergeConfiguredTargetRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget configured_target_;
  bool has_configured_target_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;

  MergeConfiguredTargetRequest() = default;
  MergeConfiguredTargetRequest(const MergeConfiguredTargetRequest&) = default;
  MergeConfiguredTargetRequest(MergeConfiguredTargetRequest&&) = default;
  MergeConfiguredTargetRequest& operator=(const MergeConfiguredTargetRequest&) = default;
  MergeConfiguredTargetRequest& operator=(MergeConfiguredTargetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget* mutable_configured_target() {
    has_configured_target_ = true;
    return &configured_target_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
};  // struct MergeConfiguredTargetRequest
struct FinalizeConfiguredTargetRequest {
  std::string name_;
  bool has_name_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  FinalizeConfiguredTargetRequest() = default;
  FinalizeConfiguredTargetRequest(const FinalizeConfiguredTargetRequest&) = default;
  FinalizeConfiguredTargetRequest(FinalizeConfiguredTargetRequest&&) = default;
  FinalizeConfiguredTargetRequest& operator=(const FinalizeConfiguredTargetRequest&) = default;
  FinalizeConfiguredTargetRequest& operator=(FinalizeConfiguredTargetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct FinalizeConfiguredTargetRequest
struct FinalizeConfiguredTargetResponse {
  std::string name_;
  bool has_name_ = false;
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget::Id id_;
  bool has_id_ = false;

  FinalizeConfiguredTargetResponse() = default;
  FinalizeConfiguredTargetResponse(const FinalizeConfiguredTargetResponse&) = default;
  FinalizeConfiguredTargetResponse(FinalizeConfiguredTargetResponse&&) = default;
  FinalizeConfiguredTargetResponse& operator=(const FinalizeConfiguredTargetResponse&) = default;
  FinalizeConfiguredTargetResponse& operator=(FinalizeConfiguredTargetResponse&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
};  // struct FinalizeConfiguredTargetResponse
struct CreateActionRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  std::string parent_;
  bool has_parent_ = false;
  std::string action_id_;
  bool has_action_id_ = false;
  ::rs::google::devtools::resultstore::v2::Action action_;
  bool has_action_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  CreateActionRequest() = default;
  CreateActionRequest(const CreateActionRequest&) = default;
  CreateActionRequest(CreateActionRequest&&) = default;
  CreateActionRequest& operator=(const CreateActionRequest&) = default;
  CreateActionRequest& operator=(CreateActionRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  std::string* mutable_parent() {
    has_parent_ = true;
    return &parent_;
  }
  void set_parent(const std::string& value);
  std::string* mutable_action_id() {
    has_action_id_ = true;
    return &action_id_;
  }
  void set_action_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Action* mutable_action() {
    has_action_ = true;
    return &action_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct CreateActionRequest
struct UpdateActionRequest {
  ::rs::google::devtools::resultstore::v2::Action action_;
  bool has_action_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;

  UpdateActionRequest() = default;
  UpdateActionRequest(const UpdateActionRequest&) = default;
  UpdateActionRequest(UpdateActionRequest&&) = default;
  UpdateActionRequest& operator=(const UpdateActionRequest&) = default;
  UpdateActionRequest& operator=(UpdateActionRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::Action* mutable_action() {
    has_action_ = true;
    return &action_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
};  // struct UpdateActionRequest
struct MergeActionRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  ::rs::google::devtools::resultstore::v2::Action action_;
  bool has_action_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;

  MergeActionRequest() = default;
  MergeActionRequest(const MergeActionRequest&) = default;
  MergeActionRequest(MergeActionRequest&&) = default;
  MergeActionRequest& operator=(const MergeActionRequest&) = default;
  MergeActionRequest& operator=(MergeActionRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Action* mutable_action() {
    has_action_ = true;
    return &action_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
};  // struct MergeActionRequest
struct CreateConfigurationRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  std::string parent_;
  bool has_parent_ = false;
  std::string config_id_;
  bool has_config_id_ = false;
  ::rs::google::devtools::resultstore::v2::Configuration configuration_;
  bool has_configuration_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  CreateConfigurationRequest() = default;
  CreateConfigurationRequest(const CreateConfigurationRequest&) = default;
  CreateConfigurationRequest(CreateConfigurationRequest&&) = default;
  CreateConfigurationRequest& operator=(const CreateConfigurationRequest&) = default;
  CreateConfigurationRequest& operator=(CreateConfigurationRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  std::string* mutable_parent() {
    has_parent_ = true;
    return &parent_;
  }
  void set_parent(const std::string& value);
  std::string* mutable_config_id() {
    has_config_id_ = true;
    return &config_id_;
  }
  void set_config_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::Configuration* mutable_configuration() {
    has_configuration_ = true;
    return &configuration_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct CreateConfigurationRequest
struct UpdateConfigurationRequest {
  ::rs::google::devtools::resultstore::v2::Configuration configuration_;
  bool has_configuration_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;

  UpdateConfigurationRequest() = default;
  UpdateConfigurationRequest(const UpdateConfigurationRequest&) = default;
  UpdateConfigurationRequest(UpdateConfigurationRequest&&) = default;
  UpdateConfigurationRequest& operator=(const UpdateConfigurationRequest&) = default;
  UpdateConfigurationRequest& operator=(UpdateConfigurationRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::Configuration* mutable_configuration() {
    has_configuration_ = true;
    return &configuration_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
};  // struct UpdateConfigurationRequest
struct CreateFileSetRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  std::string parent_;
  bool has_parent_ = false;
  std::string file_set_id_;
  bool has_file_set_id_ = false;
  ::rs::google::devtools::resultstore::v2::FileSet file_set_;
  bool has_file_set_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  CreateFileSetRequest() = default;
  CreateFileSetRequest(const CreateFileSetRequest&) = default;
  CreateFileSetRequest(CreateFileSetRequest&&) = default;
  CreateFileSetRequest& operator=(const CreateFileSetRequest&) = default;
  CreateFileSetRequest& operator=(CreateFileSetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  std::string* mutable_parent() {
    has_parent_ = true;
    return &parent_;
  }
  void set_parent(const std::string& value);
  std::string* mutable_file_set_id() {
    has_file_set_id_ = true;
    return &file_set_id_;
  }
  void set_file_set_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::FileSet* mutable_file_set() {
    has_file_set_ = true;
    return &file_set_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct CreateFileSetRequest
struct UpdateFileSetRequest {
  ::rs::google::devtools::resultstore::v2::FileSet file_set_;
  bool has_file_set_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;

  UpdateFileSetRequest() = default;
  UpdateFileSetRequest(const UpdateFileSetRequest&) = default;
  UpdateFileSetRequest(UpdateFileSetRequest&&) = default;
  UpdateFileSetRequest& operator=(const UpdateFileSetRequest&) = default;
  UpdateFileSetRequest& operator=(UpdateFileSetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::FileSet* mutable_file_set() {
    has_file_set_ = true;
    return &file_set_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
};  // struct UpdateFileSetRequest
struct MergeFileSetRequest {
  std::string request_id_;
  bool has_request_id_ = false;
  ::rs::google::devtools::resultstore::v2::FileSet file_set_;
  bool has_file_set_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;

  MergeFileSetRequest() = default;
  MergeFileSetRequest(const MergeFileSetRequest&) = default;
  MergeFileSetRequest(MergeFileSetRequest&&) = default;
  MergeFileSetRequest& operator=(const MergeFileSetRequest&) = default;
  MergeFileSetRequest& operator=(MergeFileSetRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_request_id() {
    has_request_id_ = true;
    return &request_id_;
  }
  void set_request_id(const std::string& value);
  ::rs::google::devtools::resultstore::v2::FileSet* mutable_file_set() {
    has_file_set_ = true;
    return &file_set_;
  }
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
};  // struct MergeFileSetRequest
struct UploadBatchRequest {
  std::string parent_;
  bool has_parent_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;
  std::string next_resume_token_;
  bool has_next_resume_token_ = false;
  std::string resume_token_;
  bool has_resume_token_ = false;
  std::string uploader_state_;
  bool has_uploader_state_ = false;
  std::vector< ::rs::google::devtools::resultstore::v2::UploadRequest > upload_requests_;
  bool has_upload_requests_ = false;

  UploadBatchRequest() = default;
  UploadBatchRequest(const UploadBatchRequest&) = default;
  UploadBatchRequest(UploadBatchRequest&&) = default;
  UploadBatchRequest& operator=(const UploadBatchRequest&) = default;
  UploadBatchRequest& operator=(UploadBatchRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_parent() {
    has_parent_ = true;
    return &parent_;
  }
  void set_parent(const std::string& value);
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
  std::string* mutable_next_resume_token() {
    has_next_resume_token_ = true;
    return &next_resume_token_;
  }
  void set_next_resume_token(const std::string& value);
  std::string* mutable_resume_token() {
    has_resume_token_ = true;
    return &resume_token_;
  }
  void set_resume_token(const std::string& value);
  std::string* mutable_uploader_state() {
    has_uploader_state_ = true;
    return &uploader_state_;
  }
  void set_uploader_state(const std::string& value);
  std::vector< ::rs::google::devtools::resultstore::v2::UploadRequest >* mutable_upload_requests() {
    has_upload_requests_ = true;
    return &upload_requests_;
  }
  void add_upload_requests(const ::rs::google::devtools::resultstore::v2::UploadRequest& value);
};  // struct UploadBatchRequest
struct UploadBatchResponse {
  UploadBatchResponse() = default;
  UploadBatchResponse(const UploadBatchResponse&) = default;
  UploadBatchResponse(UploadBatchResponse&&) = default;
  UploadBatchResponse& operator=(const UploadBatchResponse&) = default;
  UploadBatchResponse& operator=(UploadBatchResponse&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
};  // struct UploadBatchResponse
struct UploadRequest {
  enum UploadOperation {
    UPLOAD_OPERATION_UNSPECIFIED = 0,
    CREATE = 1,
    UPDATE = 2,
    MERGE = 3,
    FINALIZE = 4,
  };

  struct Id {
    std::string target_id_;
    bool has_target_id_ = false;
    std::string configuration_id_;
    bool has_configuration_id_ = false;
    std::string action_id_;
    bool has_action_id_ = false;
    std::string file_set_id_;
    bool has_file_set_id_ = false;

    Id() = default;
    Id(const Id&) = default;
    Id(Id&&) = default;
    Id& operator=(const Id&) = default;
    Id& operator=(Id&&) = default;
    void SerializeToOstream(OutputStream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_target_id() {
      has_target_id_ = true;
      return &target_id_;
    }
    void set_target_id(const std::string& value);
    std::string* mutable_configuration_id() {
      has_configuration_id_ = true;
      return &configuration_id_;
    }
    void set_configuration_id(const std::string& value);
    std::string* mutable_action_id() {
      has_action_id_ = true;
      return &action_id_;
    }
    void set_action_id(const std::string& value);
    std::string* mutable_file_set_id() {
      has_file_set_id_ = true;
      return &file_set_id_;
    }
    void set_file_set_id(const std::string& value);
  };  // struct Id
  ::rs::google::devtools::resultstore::v2::UploadRequest::Id id_;
  bool has_id_ = false;
  ::rs::google::devtools::resultstore::v2::UploadRequest::UploadOperation upload_operation_ = static_cast< ::rs::google::devtools::resultstore::v2::UploadRequest::UploadOperation >(0);
  bool has_upload_operation_ = false;
  ::rs::google::protobuf::FieldMask update_mask_;
  bool has_update_mask_ = false;
  bool create_if_not_found_ = false;
  bool has_create_if_not_found_ = false;
  ::rs::google::devtools::resultstore::v2::Invocation invocation_;
  bool has_invocation_ = false;
  ::rs::google::devtools::resultstore::v2::Target target_;
  bool has_target_ = false;
  ::rs::google::devtools::resultstore::v2::Configuration configuration_;
  bool has_configuration_ = false;
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget configured_target_;
  bool has_configured_target_ = false;
  ::rs::google::devtools::resultstore::v2::Action action_;
  bool has_action_ = false;
  ::rs::google::devtools::resultstore::v2::FileSet file_set_;
  bool has_file_set_ = false;

  UploadRequest() = default;
  UploadRequest(const UploadRequest&) = default;
  UploadRequest(UploadRequest&&) = default;
  UploadRequest& operator=(const UploadRequest&) = default;
  UploadRequest& operator=(UploadRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::rs::google::devtools::resultstore::v2::UploadRequest::Id* mutable_id() {
    has_id_ = true;
    return &id_;
  }
  ::rs::google::devtools::resultstore::v2::UploadRequest::UploadOperation* mutable_upload_operation() {
    has_upload_operation_ = true;
    return &upload_operation_;
  }
  void set_upload_operation(const ::rs::google::devtools::resultstore::v2::UploadRequest::UploadOperation& value);
  ::rs::google::protobuf::FieldMask* mutable_update_mask() {
    has_update_mask_ = true;
    return &update_mask_;
  }
  bool* mutable_create_if_not_found() {
    has_create_if_not_found_ = true;
    return &create_if_not_found_;
  }
  void set_create_if_not_found(const bool& value);
  ::rs::google::devtools::resultstore::v2::Invocation* mutable_invocation() {
    has_invocation_ = true;
    return &invocation_;
  }
  ::rs::google::devtools::resultstore::v2::Target* mutable_target() {
    has_target_ = true;
    return &target_;
  }
  ::rs::google::devtools::resultstore::v2::Configuration* mutable_configuration() {
    has_configuration_ = true;
    return &configuration_;
  }
  ::rs::google::devtools::resultstore::v2::ConfiguredTarget* mutable_configured_target() {
    has_configured_target_ = true;
    return &configured_target_;
  }
  ::rs::google::devtools::resultstore::v2::Action* mutable_action() {
    has_action_ = true;
    return &action_;
  }
  ::rs::google::devtools::resultstore::v2::FileSet* mutable_file_set() {
    has_file_set_ = true;
    return &file_set_;
  }
};  // struct UploadRequest
struct GetInvocationUploadMetadataRequest {
  std::string name_;
  bool has_name_ = false;
  std::string authorization_token_;
  bool has_authorization_token_ = false;

  GetInvocationUploadMetadataRequest() = default;
  GetInvocationUploadMetadataRequest(const GetInvocationUploadMetadataRequest&) = default;
  GetInvocationUploadMetadataRequest(GetInvocationUploadMetadataRequest&&) = default;
  GetInvocationUploadMetadataRequest& operator=(const GetInvocationUploadMetadataRequest&) = default;
  GetInvocationUploadMetadataRequest& operator=(GetInvocationUploadMetadataRequest&&) = default;
  void SerializeToOstream(OutputStream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::string* mutable_authorization_token() {
    has_authorization_token_ = true;
    return &authorization_token_;
  }
  void set_authorization_token(const std::string& value);
};  // struct GetInvocationUploadMetadataRequest
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
}  // namespace rs
#endif  // NINJA_RESULTSTORE_PB_H