src/build_event_stream.pb.h

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

#ifndef NINJA_BUILD_EVENT_STREAM_PB_H
#define NINJA_BUILD_EVENT_STREAM_PB_H

#include <inttypes.h>

#include <iosfwd>
#include <string>
#include <vector>

namespace bes {
namespace google {
namespace protobuf {
struct Any;
}  // namespace protobuf
}  // namespace google
namespace google {
namespace protobuf {
struct Duration;
}  // namespace protobuf
}  // namespace google
namespace google {
namespace protobuf {
struct Timestamp;
}  // namespace protobuf
}  // namespace google
namespace devtools {
namespace build {
namespace lib {
namespace packages {
namespace metrics {
struct PackageLoadMetrics;
}  // namespace metrics
}  // namespace packages
}  // namespace lib
}  // namespace build
}  // namespace devtools
namespace blaze {
struct ActionCacheStatistics;
}  // namespace blaze
namespace options {
}  // namespace options
namespace command_line {
struct CommandLine;
struct CommandLineSection;
struct ChunkList;
struct OptionList;
struct Option;
}  // namespace command_line
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 failure_details {
struct FailureDetailMetadata;
struct FailureDetail;
struct Interrupted;
struct Spawn;
struct ExternalRepository;
struct BuildProgress;
struct RemoteOptions;
struct ClientEnvironment;
struct Crash;
struct Throwable;
struct SymlinkForest;
struct BuildReport;
struct Skyfocus;
struct RemoteAnalysisCaching;
struct PackageOptions;
struct RemoteExecution;
struct Execution;
struct Workspaces;
struct CrashOptions;
struct Filesystem;
struct ExecutionOptions;
struct Command;
struct GrpcServer;
struct CanonicalizeFlags;
struct BuildConfiguration;
struct InfoCommand;
struct MemoryOptions;
struct Query;
struct LocalExecution;
struct ActionCache;
struct FetchCommand;
struct SyncCommand;
struct Sandbox;
struct IncludeScanning;
struct TestCommand;
struct ActionQuery;
struct TargetPatterns;
struct CleanCommand;
struct ConfigCommand;
struct ConfigurableQuery;
struct DumpCommand;
struct HelpCommand;
struct MobileInstall;
struct ProfileCommand;
struct RunCommand;
struct VersionCommand;
struct PrintActionCommand;
struct WorkspaceStatus;
struct JavaCompile;
struct ActionRewinding;
struct CppCompile;
struct StarlarkAction;
struct NinjaAction;
struct DynamicExecution;
struct FailAction;
struct SymlinkAction;
struct CppLink;
struct LtoAction;
struct TestAction;
struct Worker;
struct Analysis;
struct PackageLoading;
struct Toolchain;
struct StarlarkLoading;
struct ExternalDeps;
struct DiffAwareness;
struct ModCommand;
}  // namespace failure_details
namespace blaze {
namespace strategy_policy {
struct StrategyPolicy;
struct MnemonicPolicy;
struct StrategiesForMnemonic;
}  // namespace strategy_policy
}  // namespace blaze
namespace blaze {
namespace invocation_policy {
struct InvocationPolicy;
struct FlagPolicy;
struct SetValue;
struct UseDefault;
struct DisallowValues;
struct AllowValues;
}  // namespace invocation_policy
}  // namespace blaze
namespace build_event_stream {
struct BuildEventId;
struct Progress;
struct Aborted;
struct BuildStarted;
struct WorkspaceConfig;
struct UnstructuredCommandLine;
struct OptionsParsed;
struct Fetch;
struct WorkspaceStatus;
struct BuildMetadata;
struct Configuration;
struct PatternExpanded;
struct TargetConfigured;
struct File;
struct NamedSetOfFiles;
struct ActionExecuted;
struct OutputGroup;
struct TargetComplete;
struct TestResult;
struct TestProgress;
struct TestSummary;
struct TargetSummary;
struct BuildFinished;
struct BuildMetrics;
struct BuildToolLogs;
struct ConvenienceSymlinksIdentified;
struct ConvenienceSymlink;
struct ExecRequestConstructed;
struct EnvironmentVariable;
struct BuildEvent;
}  // namespace build_event_stream

namespace google {
namespace protobuf {
struct Any {
  std::string type_url_;
  bool has_type_url_;
  std::string value_;
  bool has_value_;

  Any();
  Any(const Any&) = default;
  Any(Any&&) = default;
  Any& operator=(const Any&) = default;
  Any& operator=(Any&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_type_url() {
    has_type_url_ = true;
    return &type_url_;
  }
  void set_type_url(const std::string& value);
  std::string* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const std::string& value);
};  // struct Any
}  // namespace protobuf
}  // namespace google
namespace google {
namespace protobuf {
struct Duration {
  int64_t seconds_;
  bool has_seconds_;
  int32_t nanos_;
  bool has_nanos_;

  Duration();
  Duration(const Duration&) = default;
  Duration(Duration&&) = default;
  Duration& operator=(const Duration&) = default;
  Duration& operator=(Duration&&) = default;
  void SerializeToOstream(std::ostream* 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 protobuf {
struct Timestamp {
  int64_t seconds_;
  bool has_seconds_;
  int32_t nanos_;
  bool has_nanos_;

  Timestamp();
  Timestamp(const Timestamp&) = default;
  Timestamp(Timestamp&&) = default;
  Timestamp& operator=(const Timestamp&) = default;
  Timestamp& operator=(Timestamp&&) = default;
  void SerializeToOstream(std::ostream* 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 devtools {
namespace build {
namespace lib {
namespace packages {
namespace metrics {
struct PackageLoadMetrics {
  std::string name_;
  bool has_name_;
  ::bes::google::protobuf::Duration load_duration_;
  bool has_load_duration_;
  uint64_t num_targets_;
  bool has_num_targets_;
  uint64_t computation_steps_;
  bool has_computation_steps_;
  uint64_t num_transitive_loads_;
  bool has_num_transitive_loads_;
  uint64_t package_overhead_;
  bool has_package_overhead_;

  PackageLoadMetrics();
  PackageLoadMetrics(const PackageLoadMetrics&) = default;
  PackageLoadMetrics(PackageLoadMetrics&&) = default;
  PackageLoadMetrics& operator=(const PackageLoadMetrics&) = default;
  PackageLoadMetrics& operator=(PackageLoadMetrics&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  ::bes::google::protobuf::Duration* mutable_load_duration() {
    has_load_duration_ = true;
    return &load_duration_;
  }
  uint64_t* mutable_num_targets() {
    has_num_targets_ = true;
    return &num_targets_;
  }
  void set_num_targets(const uint64_t& value);
  uint64_t* mutable_computation_steps() {
    has_computation_steps_ = true;
    return &computation_steps_;
  }
  void set_computation_steps(const uint64_t& value);
  uint64_t* mutable_num_transitive_loads() {
    has_num_transitive_loads_ = true;
    return &num_transitive_loads_;
  }
  void set_num_transitive_loads(const uint64_t& value);
  uint64_t* mutable_package_overhead() {
    has_package_overhead_ = true;
    return &package_overhead_;
  }
  void set_package_overhead(const uint64_t& value);
};  // struct PackageLoadMetrics
}  // namespace metrics
}  // namespace packages
}  // namespace lib
}  // namespace build
}  // namespace devtools
namespace blaze {
struct ActionCacheStatistics {
  enum MissReason {
    DIFFERENT_ACTION_KEY = 0,
    DIFFERENT_DEPS = 1,
    DIFFERENT_ENVIRONMENT = 2,
    DIFFERENT_FILES = 3,
    CORRUPTED_CACHE_ENTRY = 4,
    NOT_CACHED = 5,
    UNCONDITIONAL_EXECUTION = 6,
  };

  struct MissDetail {
    ::bes::blaze::ActionCacheStatistics::MissReason reason_;
    bool has_reason_;
    int32_t count_;
    bool has_count_;

    MissDetail();
    MissDetail(const MissDetail&) = default;
    MissDetail(MissDetail&&) = default;
    MissDetail& operator=(const MissDetail&) = default;
    MissDetail& operator=(MissDetail&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    ::bes::blaze::ActionCacheStatistics::MissReason* mutable_reason() {
      has_reason_ = true;
      return &reason_;
    }
    void set_reason(const ::bes::blaze::ActionCacheStatistics::MissReason& value);
    int32_t* mutable_count() {
      has_count_ = true;
      return &count_;
    }
    void set_count(const int32_t& value);
  };  // struct MissDetail
  uint64_t size_in_bytes_;
  bool has_size_in_bytes_;
  uint64_t save_time_in_ms_;
  bool has_save_time_in_ms_;
  int32_t hits_;
  bool has_hits_;
  int32_t misses_;
  bool has_misses_;
  std::vector< ::bes::blaze::ActionCacheStatistics::MissDetail > miss_details_;
  bool has_miss_details_;
  uint64_t load_time_in_ms_;
  bool has_load_time_in_ms_;

  ActionCacheStatistics();
  ActionCacheStatistics(const ActionCacheStatistics&) = default;
  ActionCacheStatistics(ActionCacheStatistics&&) = default;
  ActionCacheStatistics& operator=(const ActionCacheStatistics&) = default;
  ActionCacheStatistics& operator=(ActionCacheStatistics&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  uint64_t* mutable_size_in_bytes() {
    has_size_in_bytes_ = true;
    return &size_in_bytes_;
  }
  void set_size_in_bytes(const uint64_t& value);
  uint64_t* mutable_save_time_in_ms() {
    has_save_time_in_ms_ = true;
    return &save_time_in_ms_;
  }
  void set_save_time_in_ms(const uint64_t& value);
  int32_t* mutable_hits() {
    has_hits_ = true;
    return &hits_;
  }
  void set_hits(const int32_t& value);
  int32_t* mutable_misses() {
    has_misses_ = true;
    return &misses_;
  }
  void set_misses(const int32_t& value);
  std::vector< ::bes::blaze::ActionCacheStatistics::MissDetail >* mutable_miss_details() {
    has_miss_details_ = true;
    return &miss_details_;
  }
  void add_miss_details(const ::bes::blaze::ActionCacheStatistics::MissDetail& value);
  uint64_t* mutable_load_time_in_ms() {
    has_load_time_in_ms_ = true;
    return &load_time_in_ms_;
  }
  void set_load_time_in_ms(const uint64_t& value);
};  // struct ActionCacheStatistics
}  // namespace blaze
namespace options {
enum OptionEffectTag {
  UNKNOWN = 0,
  NO_OP = 1,
  LOSES_INCREMENTAL_STATE = 2,
  CHANGES_INPUTS = 3,
  AFFECTS_OUTPUTS = 4,
  BUILD_FILE_SEMANTICS = 5,
  BAZEL_INTERNAL_CONFIGURATION = 6,
  LOADING_AND_ANALYSIS = 7,
  EXECUTION = 8,
  HOST_MACHINE_RESOURCE_OPTIMIZATIONS = 9,
  EAGERNESS_TO_EXIT = 10,
  BAZEL_MONITORING = 11,
  TERMINAL_OUTPUT = 12,
  ACTION_COMMAND_LINES = 13,
  TEST_RUNNER = 14,
};

enum OptionMetadataTag {
  EXPERIMENTAL = 0,
  INCOMPATIBLE_CHANGE = 1,
  DEPRECATED = 2,
  HIDDEN = 3,
  INTERNAL = 4,
  IMMUTABLE = 7,
};

}  // namespace options
namespace command_line {
struct CommandLine {
  std::string command_line_label_;
  bool has_command_line_label_;
  std::vector< ::bes::command_line::CommandLineSection > sections_;
  bool has_sections_;

  CommandLine();
  CommandLine(const CommandLine&) = default;
  CommandLine(CommandLine&&) = default;
  CommandLine& operator=(const CommandLine&) = default;
  CommandLine& operator=(CommandLine&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_command_line_label() {
    has_command_line_label_ = true;
    return &command_line_label_;
  }
  void set_command_line_label(const std::string& value);
  std::vector< ::bes::command_line::CommandLineSection >* mutable_sections() {
    has_sections_ = true;
    return &sections_;
  }
  void add_sections(const ::bes::command_line::CommandLineSection& value);
};  // struct CommandLine
struct ChunkList {
  std::vector< std::string > chunk_;
  bool has_chunk_;

  ChunkList();
  ChunkList(const ChunkList&) = default;
  ChunkList(ChunkList&&) = default;
  ChunkList& operator=(const ChunkList&) = default;
  ChunkList& operator=(ChunkList&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< std::string >* mutable_chunk() {
    has_chunk_ = true;
    return &chunk_;
  }
  void add_chunk(const std::string& value);
  void set_chunk(const std::vector< std::string >& value);
};  // struct ChunkList
struct OptionList {
  std::vector< ::bes::command_line::Option > option_;
  bool has_option_;

  OptionList();
  OptionList(const OptionList&) = default;
  OptionList(OptionList&&) = default;
  OptionList& operator=(const OptionList&) = default;
  OptionList& operator=(OptionList&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::command_line::Option >* mutable_option() {
    has_option_ = true;
    return &option_;
  }
  void add_option(const ::bes::command_line::Option& value);
};  // struct OptionList
struct CommandLineSection {
  std::string section_label_;
  bool has_section_label_;
  ::bes::command_line::ChunkList chunk_list_;
  bool has_chunk_list_;
  ::bes::command_line::OptionList option_list_;
  bool has_option_list_;

  CommandLineSection();
  CommandLineSection(const CommandLineSection&) = default;
  CommandLineSection(CommandLineSection&&) = default;
  CommandLineSection& operator=(const CommandLineSection&) = default;
  CommandLineSection& operator=(CommandLineSection&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_section_label() {
    has_section_label_ = true;
    return &section_label_;
  }
  void set_section_label(const std::string& value);
  ::bes::command_line::ChunkList* mutable_chunk_list() {
    has_chunk_list_ = true;
    return &chunk_list_;
  }
  ::bes::command_line::OptionList* mutable_option_list() {
    has_option_list_ = true;
    return &option_list_;
  }
};  // struct CommandLineSection
struct Option {
  std::string combined_form_;
  bool has_combined_form_;
  std::string option_name_;
  bool has_option_name_;
  std::string option_value_;
  bool has_option_value_;
  std::vector< ::bes::options::OptionEffectTag > effect_tags_;
  bool has_effect_tags_;
  std::vector< ::bes::options::OptionMetadataTag > metadata_tags_;
  bool has_metadata_tags_;

  Option();
  Option(const Option&) = default;
  Option(Option&&) = default;
  Option& operator=(const Option&) = default;
  Option& operator=(Option&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_combined_form() {
    has_combined_form_ = true;
    return &combined_form_;
  }
  void set_combined_form(const std::string& value);
  std::string* mutable_option_name() {
    has_option_name_ = true;
    return &option_name_;
  }
  void set_option_name(const std::string& value);
  std::string* mutable_option_value() {
    has_option_value_ = true;
    return &option_value_;
  }
  void set_option_value(const std::string& value);
  std::vector< ::bes::options::OptionEffectTag >* mutable_effect_tags() {
    has_effect_tags_ = true;
    return &effect_tags_;
  }
  void add_effect_tags(const ::bes::options::OptionEffectTag& value);
  void set_effect_tags(const std::vector< ::bes::options::OptionEffectTag >& value);
  std::vector< ::bes::options::OptionMetadataTag >* mutable_metadata_tags() {
    has_metadata_tags_ = true;
    return &metadata_tags_;
  }
  void add_metadata_tags(const ::bes::options::OptionMetadataTag& value);
  void set_metadata_tags(const std::vector< ::bes::options::OptionMetadataTag >& value);
};  // struct Option
}  // namespace command_line
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< ::bes::google::protobuf::FileDescriptorProto > file_;
  bool has_file_;

  FileDescriptorSet();
  FileDescriptorSet(const FileDescriptorSet&) = default;
  FileDescriptorSet(FileDescriptorSet&&) = default;
  FileDescriptorSet& operator=(const FileDescriptorSet&) = default;
  FileDescriptorSet& operator=(FileDescriptorSet&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::google::protobuf::FileDescriptorProto >* mutable_file() {
    has_file_ = true;
    return &file_;
  }
  void add_file(const ::bes::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,
  };

  ::bes::google::protobuf::FeatureSet::FieldPresence field_presence_;
  bool has_field_presence_;
  ::bes::google::protobuf::FeatureSet::EnumType enum_type_;
  bool has_enum_type_;
  ::bes::google::protobuf::FeatureSet::RepeatedFieldEncoding repeated_field_encoding_;
  bool has_repeated_field_encoding_;
  ::bes::google::protobuf::FeatureSet::Utf8Validation utf8_validation_;
  bool has_utf8_validation_;
  ::bes::google::protobuf::FeatureSet::MessageEncoding message_encoding_;
  bool has_message_encoding_;
  ::bes::google::protobuf::FeatureSet::JsonFormat json_format_;
  bool has_json_format_;

  FeatureSet();
  FeatureSet(const FeatureSet&) = default;
  FeatureSet(FeatureSet&&) = default;
  FeatureSet& operator=(const FeatureSet&) = default;
  FeatureSet& operator=(FeatureSet&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::google::protobuf::FeatureSet::FieldPresence* mutable_field_presence() {
    has_field_presence_ = true;
    return &field_presence_;
  }
  void set_field_presence(const ::bes::google::protobuf::FeatureSet::FieldPresence& value);
  ::bes::google::protobuf::FeatureSet::EnumType* mutable_enum_type() {
    has_enum_type_ = true;
    return &enum_type_;
  }
  void set_enum_type(const ::bes::google::protobuf::FeatureSet::EnumType& value);
  ::bes::google::protobuf::FeatureSet::RepeatedFieldEncoding* mutable_repeated_field_encoding() {
    has_repeated_field_encoding_ = true;
    return &repeated_field_encoding_;
  }
  void set_repeated_field_encoding(const ::bes::google::protobuf::FeatureSet::RepeatedFieldEncoding& value);
  ::bes::google::protobuf::FeatureSet::Utf8Validation* mutable_utf8_validation() {
    has_utf8_validation_ = true;
    return &utf8_validation_;
  }
  void set_utf8_validation(const ::bes::google::protobuf::FeatureSet::Utf8Validation& value);
  ::bes::google::protobuf::FeatureSet::MessageEncoding* mutable_message_encoding() {
    has_message_encoding_ = true;
    return &message_encoding_;
  }
  void set_message_encoding(const ::bes::google::protobuf::FeatureSet::MessageEncoding& value);
  ::bes::google::protobuf::FeatureSet::JsonFormat* mutable_json_format() {
    has_json_format_ = true;
    return &json_format_;
  }
  void set_json_format(const ::bes::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_;
  std::string java_outer_classname_;
  bool has_java_outer_classname_;
  bool java_multiple_files_;
  bool has_java_multiple_files_;
  bool java_generate_equals_and_hash_;
  bool has_java_generate_equals_and_hash_;
  bool java_string_check_utf8_;
  bool has_java_string_check_utf8_;
  ::bes::google::protobuf::FileOptions::OptimizeMode optimize_for_;
  bool has_optimize_for_;
  std::string go_package_;
  bool has_go_package_;
  bool cc_generic_services_;
  bool has_cc_generic_services_;
  bool java_generic_services_;
  bool has_java_generic_services_;
  bool py_generic_services_;
  bool has_py_generic_services_;
  bool deprecated_;
  bool has_deprecated_;
  bool cc_enable_arenas_;
  bool has_cc_enable_arenas_;
  std::string objc_class_prefix_;
  bool has_objc_class_prefix_;
  std::string csharp_namespace_;
  bool has_csharp_namespace_;
  std::string swift_prefix_;
  bool has_swift_prefix_;
  std::string php_class_prefix_;
  bool has_php_class_prefix_;
  std::string php_namespace_;
  bool has_php_namespace_;
  std::string php_metadata_namespace_;
  bool has_php_metadata_namespace_;
  std::string ruby_package_;
  bool has_ruby_package_;
  ::bes::google::protobuf::FeatureSet features_;
  bool has_features_;
  std::vector< ::bes::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_;

  FileOptions();
  FileOptions(const FileOptions&) = default;
  FileOptions(FileOptions&&) = default;
  FileOptions& operator=(const FileOptions&) = default;
  FileOptions& operator=(FileOptions&&) = default;
  void SerializeToOstream(std::ostream* 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);
  ::bes::google::protobuf::FileOptions::OptimizeMode* mutable_optimize_for() {
    has_optimize_for_ = true;
    return &optimize_for_;
  }
  void set_optimize_for(const ::bes::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);
  ::bes::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  std::vector< ::bes::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::bes::google::protobuf::UninterpretedOption& value);
};  // struct FileOptions
struct SourceCodeInfo {
  struct Location {
    std::vector< int32_t > path_;
    bool has_path_;
    std::vector< int32_t > span_;
    bool has_span_;
    std::string leading_comments_;
    bool has_leading_comments_;
    std::string trailing_comments_;
    bool has_trailing_comments_;
    std::vector< std::string > leading_detached_comments_;
    bool has_leading_detached_comments_;

    Location();
    Location(const Location&) = default;
    Location(Location&&) = default;
    Location& operator=(const Location&) = default;
    Location& operator=(Location&&) = default;
    void SerializeToOstream(std::ostream* 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< ::bes::google::protobuf::SourceCodeInfo::Location > location_;
  bool has_location_;

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

  FileDescriptorProto();
  FileDescriptorProto(const FileDescriptorProto&) = default;
  FileDescriptorProto(FileDescriptorProto&&) = default;
  FileDescriptorProto& operator=(const FileDescriptorProto&) = default;
  FileDescriptorProto& operator=(FileDescriptorProto&&) = default;
  void SerializeToOstream(std::ostream* 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< ::bes::google::protobuf::DescriptorProto >* mutable_message_type() {
    has_message_type_ = true;
    return &message_type_;
  }
  void add_message_type(const ::bes::google::protobuf::DescriptorProto& value);
  std::vector< ::bes::google::protobuf::EnumDescriptorProto >* mutable_enum_type() {
    has_enum_type_ = true;
    return &enum_type_;
  }
  void add_enum_type(const ::bes::google::protobuf::EnumDescriptorProto& value);
  std::vector< ::bes::google::protobuf::ServiceDescriptorProto >* mutable_service() {
    has_service_ = true;
    return &service_;
  }
  void add_service(const ::bes::google::protobuf::ServiceDescriptorProto& value);
  std::vector< ::bes::google::protobuf::FieldDescriptorProto >* mutable_extension() {
    has_extension_ = true;
    return &extension_;
  }
  void add_extension(const ::bes::google::protobuf::FieldDescriptorProto& value);
  ::bes::google::protobuf::FileOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
  ::bes::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);
  ::bes::google::protobuf::Edition* mutable_edition() {
    has_edition_ = true;
    return &edition_;
  }
  void set_edition(const ::bes::google::protobuf::Edition& value);
};  // struct FileDescriptorProto
struct ExtensionRangeOptions {
  enum VerificationState {
    DECLARATION = 0,
    UNVERIFIED = 1,
  };

  struct Declaration {
    int32_t number_;
    bool has_number_;
    std::string full_name_;
    bool has_full_name_;
    std::string type_;
    bool has_type_;
    bool reserved_;
    bool has_reserved_;
    bool repeated_;
    bool has_repeated_;

    Declaration();
    Declaration(const Declaration&) = default;
    Declaration(Declaration&&) = default;
    Declaration& operator=(const Declaration&) = default;
    Declaration& operator=(Declaration&&) = default;
    void SerializeToOstream(std::ostream* 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< ::bes::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_;
  std::vector< ::bes::google::protobuf::ExtensionRangeOptions::Declaration > declaration_;
  bool has_declaration_;
  ::bes::google::protobuf::FeatureSet features_;
  bool has_features_;
  ::bes::google::protobuf::ExtensionRangeOptions::VerificationState verification_;
  bool has_verification_;

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

  MessageOptions();
  MessageOptions(const MessageOptions&) = default;
  MessageOptions(MessageOptions&&) = default;
  MessageOptions& operator=(const MessageOptions&) = default;
  MessageOptions& operator=(MessageOptions&&) = default;
  void SerializeToOstream(std::ostream* 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);
  ::bes::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  std::vector< ::bes::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::bes::google::protobuf::UninterpretedOption& value);
};  // struct MessageOptions
struct DescriptorProto {
  struct ExtensionRange {
    int32_t start_;
    bool has_start_;
    int32_t end_;
    bool has_end_;
    ::bes::google::protobuf::ExtensionRangeOptions options_;
    bool has_options_;

    ExtensionRange();
    ExtensionRange(const ExtensionRange&) = default;
    ExtensionRange(ExtensionRange&&) = default;
    ExtensionRange& operator=(const ExtensionRange&) = default;
    ExtensionRange& operator=(ExtensionRange&&) = default;
    void SerializeToOstream(std::ostream* 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);
    ::bes::google::protobuf::ExtensionRangeOptions* mutable_options() {
      has_options_ = true;
      return &options_;
    }
  };  // struct ExtensionRange
  struct ReservedRange {
    int32_t start_;
    bool has_start_;
    int32_t end_;
    bool has_end_;

    ReservedRange();
    ReservedRange(const ReservedRange&) = default;
    ReservedRange(ReservedRange&&) = default;
    ReservedRange& operator=(const ReservedRange&) = default;
    ReservedRange& operator=(ReservedRange&&) = default;
    void SerializeToOstream(std::ostream* 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_;
  std::vector< ::bes::google::protobuf::FieldDescriptorProto > field_;
  bool has_field_;
  std::vector< ::bes::google::protobuf::FieldDescriptorProto > extension_;
  bool has_extension_;
  std::vector< ::bes::google::protobuf::DescriptorProto > nested_type_;
  bool has_nested_type_;
  std::vector< ::bes::google::protobuf::EnumDescriptorProto > enum_type_;
  bool has_enum_type_;
  std::vector< ::bes::google::protobuf::DescriptorProto::ExtensionRange > extension_range_;
  bool has_extension_range_;
  std::vector< ::bes::google::protobuf::OneofDescriptorProto > oneof_decl_;
  bool has_oneof_decl_;
  ::bes::google::protobuf::MessageOptions options_;
  bool has_options_;
  std::vector< ::bes::google::protobuf::DescriptorProto::ReservedRange > reserved_range_;
  bool has_reserved_range_;
  std::vector< std::string > reserved_name_;
  bool has_reserved_name_;

  DescriptorProto();
  DescriptorProto(const DescriptorProto&) = default;
  DescriptorProto(DescriptorProto&&) = default;
  DescriptorProto& operator=(const DescriptorProto&) = default;
  DescriptorProto& operator=(DescriptorProto&&) = default;
  void SerializeToOstream(std::ostream* 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< ::bes::google::protobuf::FieldDescriptorProto >* mutable_field() {
    has_field_ = true;
    return &field_;
  }
  void add_field(const ::bes::google::protobuf::FieldDescriptorProto& value);
  std::vector< ::bes::google::protobuf::FieldDescriptorProto >* mutable_extension() {
    has_extension_ = true;
    return &extension_;
  }
  void add_extension(const ::bes::google::protobuf::FieldDescriptorProto& value);
  std::vector< ::bes::google::protobuf::DescriptorProto >* mutable_nested_type() {
    has_nested_type_ = true;
    return &nested_type_;
  }
  void add_nested_type(const ::bes::google::protobuf::DescriptorProto& value);
  std::vector< ::bes::google::protobuf::EnumDescriptorProto >* mutable_enum_type() {
    has_enum_type_ = true;
    return &enum_type_;
  }
  void add_enum_type(const ::bes::google::protobuf::EnumDescriptorProto& value);
  std::vector< ::bes::google::protobuf::DescriptorProto::ExtensionRange >* mutable_extension_range() {
    has_extension_range_ = true;
    return &extension_range_;
  }
  void add_extension_range(const ::bes::google::protobuf::DescriptorProto::ExtensionRange& value);
  std::vector< ::bes::google::protobuf::OneofDescriptorProto >* mutable_oneof_decl() {
    has_oneof_decl_ = true;
    return &oneof_decl_;
  }
  void add_oneof_decl(const ::bes::google::protobuf::OneofDescriptorProto& value);
  ::bes::google::protobuf::MessageOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
  std::vector< ::bes::google::protobuf::DescriptorProto::ReservedRange >* mutable_reserved_range() {
    has_reserved_range_ = true;
    return &reserved_range_;
  }
  void add_reserved_range(const ::bes::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 {
    ::bes::google::protobuf::Edition edition_;
    bool has_edition_;
    std::string value_;
    bool has_value_;

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

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

  FieldOptions();
  FieldOptions(const FieldOptions&) = default;
  FieldOptions(FieldOptions&&) = default;
  FieldOptions& operator=(const FieldOptions&) = default;
  FieldOptions& operator=(FieldOptions&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::google::protobuf::FieldOptions::CType* mutable_ctype() {
    has_ctype_ = true;
    return &ctype_;
  }
  void set_ctype(const ::bes::google::protobuf::FieldOptions::CType& value);
  bool* mutable_packed() {
    has_packed_ = true;
    return &packed_;
  }
  void set_packed(const bool& value);
  ::bes::google::protobuf::FieldOptions::JSType* mutable_jstype() {
    has_jstype_ = true;
    return &jstype_;
  }
  void set_jstype(const ::bes::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);
  ::bes::google::protobuf::FieldOptions::OptionRetention* mutable_retention() {
    has_retention_ = true;
    return &retention_;
  }
  void set_retention(const ::bes::google::protobuf::FieldOptions::OptionRetention& value);
  std::vector< ::bes::google::protobuf::FieldOptions::OptionTargetType >* mutable_targets() {
    has_targets_ = true;
    return &targets_;
  }
  void add_targets(const ::bes::google::protobuf::FieldOptions::OptionTargetType& value);
  void set_targets(const std::vector< ::bes::google::protobuf::FieldOptions::OptionTargetType >& value);
  std::vector< ::bes::google::protobuf::FieldOptions::EditionDefault >* mutable_edition_defaults() {
    has_edition_defaults_ = true;
    return &edition_defaults_;
  }
  void add_edition_defaults(const ::bes::google::protobuf::FieldOptions::EditionDefault& value);
  ::bes::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  ::bes::google::protobuf::FieldOptions::FeatureSupport* mutable_feature_support() {
    has_feature_support_ = true;
    return &feature_support_;
  }
  std::vector< ::bes::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::bes::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_;
  int32_t number_;
  bool has_number_;
  ::bes::google::protobuf::FieldDescriptorProto::Label label_;
  bool has_label_;
  ::bes::google::protobuf::FieldDescriptorProto::Type type_;
  bool has_type_;
  std::string type_name_;
  bool has_type_name_;
  std::string extendee_;
  bool has_extendee_;
  std::string default_value_;
  bool has_default_value_;
  int32_t oneof_index_;
  bool has_oneof_index_;
  std::string json_name_;
  bool has_json_name_;
  ::bes::google::protobuf::FieldOptions options_;
  bool has_options_;
  bool proto3_optional_;
  bool has_proto3_optional_;

  FieldDescriptorProto();
  FieldDescriptorProto(const FieldDescriptorProto&) = default;
  FieldDescriptorProto(FieldDescriptorProto&&) = default;
  FieldDescriptorProto& operator=(const FieldDescriptorProto&) = default;
  FieldDescriptorProto& operator=(FieldDescriptorProto&&) = default;
  void SerializeToOstream(std::ostream* 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);
  ::bes::google::protobuf::FieldDescriptorProto::Label* mutable_label() {
    has_label_ = true;
    return &label_;
  }
  void set_label(const ::bes::google::protobuf::FieldDescriptorProto::Label& value);
  ::bes::google::protobuf::FieldDescriptorProto::Type* mutable_type() {
    has_type_ = true;
    return &type_;
  }
  void set_type(const ::bes::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);
  ::bes::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 {
  ::bes::google::protobuf::FeatureSet features_;
  bool has_features_;
  std::vector< ::bes::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_;

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

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

  EnumOptions();
  EnumOptions(const EnumOptions&) = default;
  EnumOptions(EnumOptions&&) = default;
  EnumOptions& operator=(const EnumOptions&) = default;
  EnumOptions& operator=(EnumOptions&&) = default;
  void SerializeToOstream(std::ostream* 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);
  ::bes::google::protobuf::FeatureSet* mutable_features() {
    has_features_ = true;
    return &features_;
  }
  std::vector< ::bes::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::bes::google::protobuf::UninterpretedOption& value);
};  // struct EnumOptions
struct EnumDescriptorProto {
  struct EnumReservedRange {
    int32_t start_;
    bool has_start_;
    int32_t end_;
    bool has_end_;

    EnumReservedRange();
    EnumReservedRange(const EnumReservedRange&) = default;
    EnumReservedRange(EnumReservedRange&&) = default;
    EnumReservedRange& operator=(const EnumReservedRange&) = default;
    EnumReservedRange& operator=(EnumReservedRange&&) = default;
    void SerializeToOstream(std::ostream* 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_;
  std::vector< ::bes::google::protobuf::EnumValueDescriptorProto > value_;
  bool has_value_;
  ::bes::google::protobuf::EnumOptions options_;
  bool has_options_;
  std::vector< ::bes::google::protobuf::EnumDescriptorProto::EnumReservedRange > reserved_range_;
  bool has_reserved_range_;
  std::vector< std::string > reserved_name_;
  bool has_reserved_name_;

  EnumDescriptorProto();
  EnumDescriptorProto(const EnumDescriptorProto&) = default;
  EnumDescriptorProto(EnumDescriptorProto&&) = default;
  EnumDescriptorProto& operator=(const EnumDescriptorProto&) = default;
  EnumDescriptorProto& operator=(EnumDescriptorProto&&) = default;
  void SerializeToOstream(std::ostream* 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< ::bes::google::protobuf::EnumValueDescriptorProto >* mutable_value() {
    has_value_ = true;
    return &value_;
  }
  void add_value(const ::bes::google::protobuf::EnumValueDescriptorProto& value);
  ::bes::google::protobuf::EnumOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
  std::vector< ::bes::google::protobuf::EnumDescriptorProto::EnumReservedRange >* mutable_reserved_range() {
    has_reserved_range_ = true;
    return &reserved_range_;
  }
  void add_reserved_range(const ::bes::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_;
  bool has_deprecated_;
  ::bes::google::protobuf::FeatureSet features_;
  bool has_features_;
  bool debug_redact_;
  bool has_debug_redact_;
  ::bes::google::protobuf::FieldOptions::FeatureSupport feature_support_;
  bool has_feature_support_;
  std::vector< ::bes::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_;

  EnumValueOptions();
  EnumValueOptions(const EnumValueOptions&) = default;
  EnumValueOptions(EnumValueOptions&&) = default;
  EnumValueOptions& operator=(const EnumValueOptions&) = default;
  EnumValueOptions& operator=(EnumValueOptions&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_deprecated() {
    has_deprecated_ = true;
    return &deprecated_;
  }
  void set_deprecated(const bool& value);
  ::bes::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);
  ::bes::google::protobuf::FieldOptions::FeatureSupport* mutable_feature_support() {
    has_feature_support_ = true;
    return &feature_support_;
  }
  std::vector< ::bes::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::bes::google::protobuf::UninterpretedOption& value);
};  // struct EnumValueOptions
struct EnumValueDescriptorProto {
  std::string name_;
  bool has_name_;
  int32_t number_;
  bool has_number_;
  ::bes::google::protobuf::EnumValueOptions options_;
  bool has_options_;

  EnumValueDescriptorProto();
  EnumValueDescriptorProto(const EnumValueDescriptorProto&) = default;
  EnumValueDescriptorProto(EnumValueDescriptorProto&&) = default;
  EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto&) = default;
  EnumValueDescriptorProto& operator=(EnumValueDescriptorProto&&) = default;
  void SerializeToOstream(std::ostream* 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);
  ::bes::google::protobuf::EnumValueOptions* mutable_options() {
    has_options_ = true;
    return &options_;
  }
};  // struct EnumValueDescriptorProto
struct ServiceOptions {
  ::bes::google::protobuf::FeatureSet features_;
  bool has_features_;
  bool deprecated_;
  bool has_deprecated_;
  std::vector< ::bes::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_;

  ServiceOptions();
  ServiceOptions(const ServiceOptions&) = default;
  ServiceOptions(ServiceOptions&&) = default;
  ServiceOptions& operator=(const ServiceOptions&) = default;
  ServiceOptions& operator=(ServiceOptions&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::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< ::bes::google::protobuf::UninterpretedOption >* mutable_uninterpreted_option() {
    has_uninterpreted_option_ = true;
    return &uninterpreted_option_;
  }
  void add_uninterpreted_option(const ::bes::google::protobuf::UninterpretedOption& value);
};  // struct ServiceOptions
struct ServiceDescriptorProto {
  std::string name_;
  bool has_name_;
  std::vector< ::bes::google::protobuf::MethodDescriptorProto > method_;
  bool has_method_;
  ::bes::google::protobuf::ServiceOptions options_;
  bool has_options_;

  ServiceDescriptorProto();
  ServiceDescriptorProto(const ServiceDescriptorProto&) = default;
  ServiceDescriptorProto(ServiceDescriptorProto&&) = default;
  ServiceDescriptorProto& operator=(const ServiceDescriptorProto&) = default;
  ServiceDescriptorProto& operator=(ServiceDescriptorProto&&) = default;
  void SerializeToOstream(std::ostream* 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< ::bes::google::protobuf::MethodDescriptorProto >* mutable_method() {
    has_method_ = true;
    return &method_;
  }
  void add_method(const ::bes::google::protobuf::MethodDescriptorProto& value);
  ::bes::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_;
  bool has_deprecated_;
  ::bes::google::protobuf::MethodOptions::IdempotencyLevel idempotency_level_;
  bool has_idempotency_level_;
  ::bes::google::protobuf::FeatureSet features_;
  bool has_features_;
  std::vector< ::bes::google::protobuf::UninterpretedOption > uninterpreted_option_;
  bool has_uninterpreted_option_;

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

  MethodDescriptorProto();
  MethodDescriptorProto(const MethodDescriptorProto&) = default;
  MethodDescriptorProto(MethodDescriptorProto&&) = default;
  MethodDescriptorProto& operator=(const MethodDescriptorProto&) = default;
  MethodDescriptorProto& operator=(MethodDescriptorProto&&) = default;
  void SerializeToOstream(std::ostream* 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);
  ::bes::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_;
    bool is_extension_;
    bool has_is_extension_;

    NamePart();
    NamePart(const NamePart&) = default;
    NamePart(NamePart&&) = default;
    NamePart& operator=(const NamePart&) = default;
    NamePart& operator=(NamePart&&) = default;
    void SerializeToOstream(std::ostream* 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< ::bes::google::protobuf::UninterpretedOption::NamePart > name_;
  bool has_name_;
  std::string identifier_value_;
  bool has_identifier_value_;
  uint64_t positive_int_value_;
  bool has_positive_int_value_;
  int64_t negative_int_value_;
  bool has_negative_int_value_;
  double double_value_;
  bool has_double_value_;
  std::string string_value_;
  bool has_string_value_;
  std::string aggregate_value_;
  bool has_aggregate_value_;

  UninterpretedOption();
  UninterpretedOption(const UninterpretedOption&) = default;
  UninterpretedOption(UninterpretedOption&&) = default;
  UninterpretedOption& operator=(const UninterpretedOption&) = default;
  UninterpretedOption& operator=(UninterpretedOption&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::google::protobuf::UninterpretedOption::NamePart >* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void add_name(const ::bes::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 {
    ::bes::google::protobuf::Edition edition_;
    bool has_edition_;
    ::bes::google::protobuf::FeatureSet overridable_features_;
    bool has_overridable_features_;
    ::bes::google::protobuf::FeatureSet fixed_features_;
    bool has_fixed_features_;

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

  FeatureSetDefaults();
  FeatureSetDefaults(const FeatureSetDefaults&) = default;
  FeatureSetDefaults(FeatureSetDefaults&&) = default;
  FeatureSetDefaults& operator=(const FeatureSetDefaults&) = default;
  FeatureSetDefaults& operator=(FeatureSetDefaults&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::google::protobuf::FeatureSetDefaults::FeatureSetEditionDefault >* mutable_defaults() {
    has_defaults_ = true;
    return &defaults_;
  }
  void add_defaults(const ::bes::google::protobuf::FeatureSetDefaults::FeatureSetEditionDefault& value);
  ::bes::google::protobuf::Edition* mutable_minimum_edition() {
    has_minimum_edition_ = true;
    return &minimum_edition_;
  }
  void set_minimum_edition(const ::bes::google::protobuf::Edition& value);
  ::bes::google::protobuf::Edition* mutable_maximum_edition() {
    has_maximum_edition_ = true;
    return &maximum_edition_;
  }
  void set_maximum_edition(const ::bes::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_;
    std::string source_file_;
    bool has_source_file_;
    int32_t begin_;
    bool has_begin_;
    int32_t end_;
    bool has_end_;
    ::bes::google::protobuf::GeneratedCodeInfo::Annotation::Semantic semantic_;
    bool has_semantic_;

    Annotation();
    Annotation(const Annotation&) = default;
    Annotation(Annotation&&) = default;
    Annotation& operator=(const Annotation&) = default;
    Annotation& operator=(Annotation&&) = default;
    void SerializeToOstream(std::ostream* 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);
    ::bes::google::protobuf::GeneratedCodeInfo::Annotation::Semantic* mutable_semantic() {
      has_semantic_ = true;
      return &semantic_;
    }
    void set_semantic(const ::bes::google::protobuf::GeneratedCodeInfo::Annotation::Semantic& value);
  };  // struct Annotation
  std::vector< ::bes::google::protobuf::GeneratedCodeInfo::Annotation > annotation_;
  bool has_annotation_;

  GeneratedCodeInfo();
  GeneratedCodeInfo(const GeneratedCodeInfo&) = default;
  GeneratedCodeInfo(GeneratedCodeInfo&&) = default;
  GeneratedCodeInfo& operator=(const GeneratedCodeInfo&) = default;
  GeneratedCodeInfo& operator=(GeneratedCodeInfo&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::google::protobuf::GeneratedCodeInfo::Annotation >* mutable_annotation() {
    has_annotation_ = true;
    return &annotation_;
  }
  void add_annotation(const ::bes::google::protobuf::GeneratedCodeInfo::Annotation& value);
};  // struct GeneratedCodeInfo
}  // namespace protobuf
}  // namespace google
namespace failure_details {
struct FailureDetailMetadata {
  uint32_t exit_code_;
  bool has_exit_code_;

  FailureDetailMetadata();
  FailureDetailMetadata(const FailureDetailMetadata&) = default;
  FailureDetailMetadata(FailureDetailMetadata&&) = default;
  FailureDetailMetadata& operator=(const FailureDetailMetadata&) = default;
  FailureDetailMetadata& operator=(FailureDetailMetadata&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  uint32_t* mutable_exit_code() {
    has_exit_code_ = true;
    return &exit_code_;
  }
  void set_exit_code(const uint32_t& value);
};  // struct FailureDetailMetadata
struct ActionCache {
  enum Code {
    ACTION_CACHE_UNKNOWN = 0,
    INITIALIZATION_FAILURE = 1,
  };

  ::bes::failure_details::ActionCache::Code code_;
  bool has_code_;

  ActionCache();
  ActionCache(const ActionCache&) = default;
  ActionCache(ActionCache&&) = default;
  ActionCache& operator=(const ActionCache&) = default;
  ActionCache& operator=(ActionCache&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ActionCache::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ActionCache::Code& value);
};  // struct ActionCache
struct ActionQuery {
  enum Code {
    ACTION_QUERY_UNKNOWN = 0,
    COMMAND_LINE_EXPANSION_FAILURE = 1,
    OUTPUT_FAILURE = 2,
    COMMAND_LINE_EXPRESSION_MISSING = 3,
    EXPRESSION_PARSE_FAILURE = 4,
    SKYFRAME_STATE_WITH_COMMAND_LINE_EXPRESSION = 5,
    INVALID_AQUERY_EXPRESSION = 6,
    SKYFRAME_STATE_PREREQ_UNMET = 7,
    AQUERY_OUTPUT_TOO_BIG = 8,
    ILLEGAL_PATTERN_SYNTAX = 9,
    INCORRECT_ARGUMENTS = 10,
    TOP_LEVEL_TARGETS_WITH_SKYFRAME_STATE_NOT_SUPPORTED = 11,
    SKYFRAME_STATE_AFTER_EXECUTION = 12,
    LABELS_FUNCTION_NOT_SUPPORTED = 13,
    TEMPLATE_EXPANSION_FAILURE = 14,
  };

  ::bes::failure_details::ActionQuery::Code code_;
  bool has_code_;

  ActionQuery();
  ActionQuery(const ActionQuery&) = default;
  ActionQuery(ActionQuery&&) = default;
  ActionQuery& operator=(const ActionQuery&) = default;
  ActionQuery& operator=(ActionQuery&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ActionQuery::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ActionQuery::Code& value);
};  // struct ActionQuery
struct ActionRewinding {
  enum Code {
    ACTION_REWINDING_UNKNOWN = 0,
    LOST_INPUT_TOO_MANY_TIMES = 1,
    REWIND_LOST_INPUTS_PREREQ_UNMET = 3,
    LOST_OUTPUT_TOO_MANY_TIMES = 4,
    LOST_INPUT_REWINDING_DISABLED = 5,
    LOST_OUTPUT_REWINDING_DISABLED = 6,
    DEPRECATED_LOST_INPUT_IS_SOURCE = 2,
  };

  ::bes::failure_details::ActionRewinding::Code code_;
  bool has_code_;

  ActionRewinding();
  ActionRewinding(const ActionRewinding&) = default;
  ActionRewinding(ActionRewinding&&) = default;
  ActionRewinding& operator=(const ActionRewinding&) = default;
  ActionRewinding& operator=(ActionRewinding&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ActionRewinding::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ActionRewinding::Code& value);
};  // struct ActionRewinding
struct Analysis {
  enum Code {
    ANALYSIS_UNKNOWN = 0,
    LOAD_FAILURE = 1,
    GENERIC_LOADING_PHASE_FAILURE = 2,
    NOT_ALL_TARGETS_ANALYZED = 3,
    CYCLE = 4,
    PARAMETERIZED_TOP_LEVEL_ASPECT_INVALID = 5,
    ASPECT_LABEL_SYNTAX_ERROR = 6,
    ASPECT_PREREQ_UNMET = 7,
    ASPECT_NOT_FOUND = 8,
    ACTION_CONFLICT = 9,
    ARTIFACT_PREFIX_CONFLICT = 10,
    UNEXPECTED_ANALYSIS_EXCEPTION = 11,
    TARGETS_MISSING_ENVIRONMENTS = 12,
    INVALID_ENVIRONMENT = 13,
    ENVIRONMENT_MISSING_FROM_GROUPS = 14,
    EXEC_GROUP_MISSING = 15,
    INVALID_EXECUTION_PLATFORM = 16,
    ASPECT_CREATION_FAILED = 17,
    CONFIGURED_VALUE_CREATION_FAILED = 18,
    INCOMPATIBLE_TARGET_REQUESTED = 19,
    ANALYSIS_FAILURE_PROPAGATION_FAILED = 20,
    ANALYSIS_CACHE_DISCARDED = 21,
  };

  ::bes::failure_details::Analysis::Code code_;
  bool has_code_;

  Analysis();
  Analysis(const Analysis&) = default;
  Analysis(Analysis&&) = default;
  Analysis& operator=(const Analysis&) = default;
  Analysis& operator=(Analysis&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Analysis::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Analysis::Code& value);
};  // struct Analysis
struct BuildConfiguration {
  enum Code {
    BUILD_CONFIGURATION_UNKNOWN = 0,
    PLATFORM_MAPPING_EVALUATION_FAILURE = 1,
    PLATFORM_MAPPINGS_FILE_IS_DIRECTORY = 2,
    PLATFORM_MAPPINGS_FILE_NOT_FOUND = 3,
    TOP_LEVEL_CONFIGURATION_CREATION_FAILURE = 4,
    INVALID_CONFIGURATION = 5,
    INVALID_BUILD_OPTIONS = 6,
    MULTI_CPU_PREREQ_UNMET = 7,
    HEURISTIC_INSTRUMENTATION_FILTER_INVALID = 8,
    CYCLE = 9,
    CONFLICTING_CONFIGURATIONS = 10,
    INVALID_OUTPUT_DIRECTORY_MNEMONIC = 11,
    CONFIGURATION_DISCARDED_ANALYSIS_CACHE = 12,
    INVALID_PROJECT = 13,
  };

  ::bes::failure_details::BuildConfiguration::Code code_;
  bool has_code_;

  BuildConfiguration();
  BuildConfiguration(const BuildConfiguration&) = default;
  BuildConfiguration(BuildConfiguration&&) = default;
  BuildConfiguration& operator=(const BuildConfiguration&) = default;
  BuildConfiguration& operator=(BuildConfiguration&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::BuildConfiguration::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::BuildConfiguration::Code& value);
};  // struct BuildConfiguration
struct BuildProgress {
  enum Code {
    BUILD_PROGRESS_UNKNOWN = 0,
    OUTPUT_INITIALIZATION = 3,
    BES_RUNS_PER_TEST_LIMIT_UNSUPPORTED = 4,
    BES_LOCAL_WRITE_ERROR = 5,
    BES_INITIALIZATION_ERROR = 6,
    BES_UPLOAD_TIMEOUT_ERROR = 7,
    BES_FILE_WRITE_TIMEOUT = 8,
    BES_FILE_WRITE_IO_ERROR = 9,
    BES_FILE_WRITE_INTERRUPTED = 10,
    BES_FILE_WRITE_CANCELED = 11,
    BES_FILE_WRITE_UNKNOWN_ERROR = 12,
    BES_UPLOAD_LOCAL_FILE_ERROR = 13,
    BES_STREAM_NOT_RETRYING_FAILURE = 14,
    BES_STREAM_COMPLETED_WITH_UNACK_EVENTS_ERROR = 15,
    BES_STREAM_COMPLETED_WITH_UNSENT_EVENTS_ERROR = 16,
    BES_STREAM_COMPLETED_WITH_REMOTE_ERROR = 19,
    BES_UPLOAD_RETRY_LIMIT_EXCEEDED_FAILURE = 17,
  };

  ::bes::failure_details::BuildProgress::Code code_;
  bool has_code_;

  BuildProgress();
  BuildProgress(const BuildProgress&) = default;
  BuildProgress(BuildProgress&&) = default;
  BuildProgress& operator=(const BuildProgress&) = default;
  BuildProgress& operator=(BuildProgress&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::BuildProgress::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::BuildProgress::Code& value);
};  // struct BuildProgress
struct BuildReport {
  enum Code {
    BUILD_REPORT_UNKNOWN = 0,
    BUILD_REPORT_UPLOADER_NEEDS_PACKAGE_PATHS = 1,
    BUILD_REPORT_WRITE_FAILED = 2,
  };

  ::bes::failure_details::BuildReport::Code code_;
  bool has_code_;

  BuildReport();
  BuildReport(const BuildReport&) = default;
  BuildReport(BuildReport&&) = default;
  BuildReport& operator=(const BuildReport&) = default;
  BuildReport& operator=(BuildReport&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::BuildReport::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::BuildReport::Code& value);
};  // struct BuildReport
struct CanonicalizeFlags {
  enum Code {
    CANONICALIZE_FLAGS_UNKNOWN = 0,
    FOR_COMMAND_INVALID = 1,
  };

  ::bes::failure_details::CanonicalizeFlags::Code code_;
  bool has_code_;

  CanonicalizeFlags();
  CanonicalizeFlags(const CanonicalizeFlags&) = default;
  CanonicalizeFlags(CanonicalizeFlags&&) = default;
  CanonicalizeFlags& operator=(const CanonicalizeFlags&) = default;
  CanonicalizeFlags& operator=(CanonicalizeFlags&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::CanonicalizeFlags::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::CanonicalizeFlags::Code& value);
};  // struct CanonicalizeFlags
struct CleanCommand {
  enum Code {
    CLEAN_COMMAND_UNKNOWN = 0,
    OUTPUT_SERVICE_CLEAN_FAILURE = 1,
    ACTION_CACHE_CLEAN_FAILURE = 2,
    OUT_ERR_CLOSE_FAILURE = 3,
    OUTPUT_BASE_DELETE_FAILURE = 4,
    OUTPUT_BASE_TEMP_MOVE_FAILURE = 5,
    ASYNC_OUTPUT_BASE_DELETE_FAILURE = 6,
    EXECROOT_DELETE_FAILURE = 7,
    EXECROOT_TEMP_MOVE_FAILURE = 8,
    ASYNC_EXECROOT_DELETE_FAILURE = 9,
    ARGUMENTS_NOT_RECOGNIZED = 10,
  };

  ::bes::failure_details::CleanCommand::Code code_;
  bool has_code_;

  CleanCommand();
  CleanCommand(const CleanCommand&) = default;
  CleanCommand(CleanCommand&&) = default;
  CleanCommand& operator=(const CleanCommand&) = default;
  CleanCommand& operator=(CleanCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::CleanCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::CleanCommand::Code& value);
};  // struct CleanCommand
struct ClientEnvironment {
  enum Code {
    CLIENT_ENVIRONMENT_UNKNOWN = 0,
    CLIENT_CWD_MALFORMED = 1,
  };

  ::bes::failure_details::ClientEnvironment::Code code_;
  bool has_code_;

  ClientEnvironment();
  ClientEnvironment(const ClientEnvironment&) = default;
  ClientEnvironment(ClientEnvironment&&) = default;
  ClientEnvironment& operator=(const ClientEnvironment&) = default;
  ClientEnvironment& operator=(ClientEnvironment&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ClientEnvironment::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ClientEnvironment::Code& value);
};  // struct ClientEnvironment
struct Command {
  enum Code {
    COMMAND_FAILURE_UNKNOWN = 0,
    COMMAND_NOT_FOUND = 1,
    ANOTHER_COMMAND_RUNNING = 2,
    PREVIOUSLY_SHUTDOWN = 3,
    STARLARK_CPU_PROFILE_FILE_INITIALIZATION_FAILURE = 4,
    STARLARK_CPU_PROFILING_INITIALIZATION_FAILURE = 5,
    STARLARK_CPU_PROFILE_FILE_WRITE_FAILURE = 6,
    INVOCATION_POLICY_PARSE_FAILURE = 7,
    INVOCATION_POLICY_INVALID = 8,
    OPTIONS_PARSE_FAILURE = 9,
    STARLARK_OPTIONS_PARSE_FAILURE = 10,
    ARGUMENTS_NOT_RECOGNIZED = 11,
    NOT_IN_WORKSPACE = 12,
    IN_OUTPUT_DIRECTORY = 14,
  };

  ::bes::failure_details::Command::Code code_;
  bool has_code_;

  Command();
  Command(const Command&) = default;
  Command(Command&&) = default;
  Command& operator=(const Command&) = default;
  Command& operator=(Command&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Command::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Command::Code& value);
};  // struct Command
struct ConfigCommand {
  enum Code {
    CONFIG_COMMAND_UNKNOWN = 0,
    TOO_MANY_CONFIG_IDS = 1,
    CONFIGURATION_NOT_FOUND = 2,
  };

  ::bes::failure_details::ConfigCommand::Code code_;
  bool has_code_;

  ConfigCommand();
  ConfigCommand(const ConfigCommand&) = default;
  ConfigCommand(ConfigCommand&&) = default;
  ConfigCommand& operator=(const ConfigCommand&) = default;
  ConfigCommand& operator=(ConfigCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ConfigCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ConfigCommand::Code& value);
};  // struct ConfigCommand
struct ConfigurableQuery {
  enum Code {
    CONFIGURABLE_QUERY_UNKNOWN = 0,
    COMMAND_LINE_EXPRESSION_MISSING = 1,
    EXPRESSION_PARSE_FAILURE = 2,
    FILTERS_NOT_SUPPORTED = 3,
    BUILDFILES_FUNCTION_NOT_SUPPORTED = 4,
    SIBLINGS_FUNCTION_NOT_SUPPORTED = 5,
    VISIBLE_FUNCTION_NOT_SUPPORTED = 6,
    ATTRIBUTE_MISSING = 7,
    INCORRECT_CONFIG_ARGUMENT_ERROR = 8,
    TARGET_MISSING = 9,
    STARLARK_SYNTAX_ERROR = 10,
    STARLARK_EVAL_ERROR = 11,
    FORMAT_FUNCTION_ERROR = 12,
  };

  ::bes::failure_details::ConfigurableQuery::Code code_;
  bool has_code_;

  ConfigurableQuery();
  ConfigurableQuery(const ConfigurableQuery&) = default;
  ConfigurableQuery(ConfigurableQuery&&) = default;
  ConfigurableQuery& operator=(const ConfigurableQuery&) = default;
  ConfigurableQuery& operator=(ConfigurableQuery&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ConfigurableQuery::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ConfigurableQuery::Code& value);
};  // struct ConfigurableQuery
struct CppCompile {
  enum Code {
    CPP_COMPILE_UNKNOWN = 0,
    FIND_USED_HEADERS_IO_EXCEPTION = 1,
    COPY_OUT_ERR_FAILURE = 2,
    D_FILE_READ_FAILURE = 3,
    COMMAND_GENERATION_FAILURE = 4,
    MODULE_EXPANSION_TIMEOUT = 5,
    INCLUDE_PATH_OUTSIDE_EXEC_ROOT = 6,
    FAKE_COMMAND_GENERATION_FAILURE = 7,
    UNDECLARED_INCLUSIONS = 8,
    D_FILE_PARSE_FAILURE = 9,
    COVERAGE_NOTES_CREATION_FAILURE = 10,
    MODULE_EXPANSION_MISSING_DATA = 11,
  };

  ::bes::failure_details::CppCompile::Code code_;
  bool has_code_;

  CppCompile();
  CppCompile(const CppCompile&) = default;
  CppCompile(CppCompile&&) = default;
  CppCompile& operator=(const CppCompile&) = default;
  CppCompile& operator=(CppCompile&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::CppCompile::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::CppCompile::Code& value);
};  // struct CppCompile
struct CppLink {
  enum Code {
    CPP_LINK_UNKNOWN = 0,
    COMMAND_GENERATION_FAILURE = 1,
    FAKE_COMMAND_GENERATION_FAILURE = 2,
  };

  ::bes::failure_details::CppLink::Code code_;
  bool has_code_;

  CppLink();
  CppLink(const CppLink&) = default;
  CppLink(CppLink&&) = default;
  CppLink& operator=(const CppLink&) = default;
  CppLink& operator=(CppLink&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::CppLink::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::CppLink::Code& value);
};  // struct CppLink
struct Crash {
  enum Code {
    CRASH_UNKNOWN = 0,
    CRASH_OOM = 1,
  };

  ::bes::failure_details::Crash::Code code_;
  bool has_code_;
  std::vector< ::bes::failure_details::Throwable > causes_;
  bool has_causes_;
  bool oom_detector_override_;
  bool has_oom_detector_override_;

  Crash();
  Crash(const Crash&) = default;
  Crash(Crash&&) = default;
  Crash& operator=(const Crash&) = default;
  Crash& operator=(Crash&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Crash::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Crash::Code& value);
  std::vector< ::bes::failure_details::Throwable >* mutable_causes() {
    has_causes_ = true;
    return &causes_;
  }
  void add_causes(const ::bes::failure_details::Throwable& value);
  bool* mutable_oom_detector_override() {
    has_oom_detector_override_ = true;
    return &oom_detector_override_;
  }
  void set_oom_detector_override(const bool& value);
};  // struct Crash
struct CrashOptions {
  enum Code {
    CRASH_OPTIONS_UNKNOWN = 0,
  };

  ::bes::failure_details::CrashOptions::Code code_;
  bool has_code_;

  CrashOptions();
  CrashOptions(const CrashOptions&) = default;
  CrashOptions(CrashOptions&&) = default;
  CrashOptions& operator=(const CrashOptions&) = default;
  CrashOptions& operator=(CrashOptions&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::CrashOptions::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::CrashOptions::Code& value);
};  // struct CrashOptions
struct DiffAwareness {
  enum Code {
    DIFF_AWARENESS_UNKNOWN = 0,
    DIFF_STAT_FAILED = 1,
  };

  ::bes::failure_details::DiffAwareness::Code code_;
  bool has_code_;

  DiffAwareness();
  DiffAwareness(const DiffAwareness&) = default;
  DiffAwareness(DiffAwareness&&) = default;
  DiffAwareness& operator=(const DiffAwareness&) = default;
  DiffAwareness& operator=(DiffAwareness&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::DiffAwareness::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::DiffAwareness::Code& value);
};  // struct DiffAwareness
struct DumpCommand {
  enum Code {
    DUMP_COMMAND_UNKNOWN = 0,
    NO_OUTPUT_SPECIFIED = 1,
    ACTION_CACHE_DUMP_FAILED = 2,
    COMMAND_LINE_EXPANSION_FAILURE = 3,
    ACTION_GRAPH_DUMP_FAILED = 4,
    STARLARK_HEAP_DUMP_FAILED = 5,
    SKYFRAME_MEMORY_DUMP_FAILED = 7,
  };

  ::bes::failure_details::DumpCommand::Code code_;
  bool has_code_;

  DumpCommand();
  DumpCommand(const DumpCommand&) = default;
  DumpCommand(DumpCommand&&) = default;
  DumpCommand& operator=(const DumpCommand&) = default;
  DumpCommand& operator=(DumpCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::DumpCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::DumpCommand::Code& value);
};  // struct DumpCommand
struct DynamicExecution {
  enum Code {
    DYNAMIC_EXECUTION_UNKNOWN = 0,
    XCODE_RELATED_PREREQ_UNMET = 1,
    ACTION_LOG_MOVE_FAILURE = 2,
    RUN_FAILURE = 3,
    NO_USABLE_STRATEGY_FOUND = 4,
  };

  ::bes::failure_details::DynamicExecution::Code code_;
  bool has_code_;

  DynamicExecution();
  DynamicExecution(const DynamicExecution&) = default;
  DynamicExecution(DynamicExecution&&) = default;
  DynamicExecution& operator=(const DynamicExecution&) = default;
  DynamicExecution& operator=(DynamicExecution&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::DynamicExecution::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::DynamicExecution::Code& value);
};  // struct DynamicExecution
struct Execution {
  enum Code {
    EXECUTION_UNKNOWN = 0,
    EXECUTION_LOG_INITIALIZATION_FAILURE = 1,
    EXECUTION_LOG_WRITE_FAILURE = 2,
    EXECROOT_CREATION_FAILURE = 3,
    TEMP_ACTION_OUTPUT_DIRECTORY_DELETION_FAILURE = 4,
    TEMP_ACTION_OUTPUT_DIRECTORY_CREATION_FAILURE = 5,
    PERSISTENT_ACTION_OUTPUT_DIRECTORY_CREATION_FAILURE = 6,
    LOCAL_OUTPUT_DIRECTORY_SYMLINK_FAILURE = 7,
    LOCAL_TEMPLATE_EXPANSION_FAILURE = 9,
    INPUT_DIRECTORY_CHECK_IO_EXCEPTION = 10,
    EXTRA_ACTION_OUTPUT_CREATION_FAILURE = 11,
    TEST_RUNNER_IO_EXCEPTION = 12,
    FILE_WRITE_IO_EXCEPTION = 13,
    TEST_OUT_ERR_IO_EXCEPTION = 14,
    SYMLINK_TREE_MANIFEST_COPY_IO_EXCEPTION = 15,
    SYMLINK_TREE_MANIFEST_LINK_IO_EXCEPTION = 16,
    SYMLINK_TREE_CREATION_IO_EXCEPTION = 17,
    SYMLINK_TREE_CREATION_COMMAND_EXCEPTION = 18,
    ACTION_INPUT_READ_IO_EXCEPTION = 19,
    ACTION_NOT_UP_TO_DATE = 20,
    PSEUDO_ACTION_EXECUTION_PROHIBITED = 21,
    DISCOVERED_INPUT_DOES_NOT_EXIST = 22,
    ACTION_OUTPUTS_DELETION_FAILURE = 23,
    ACTION_OUTPUTS_NOT_CREATED = 24,
    ACTION_FINALIZATION_FAILURE = 25,
    ACTION_INPUT_LOST = 26,
    FILESYSTEM_CONTEXT_UPDATE_FAILURE = 27,
    ACTION_OUTPUT_CLOSE_FAILURE = 28,
    INPUT_DISCOVERY_IO_EXCEPTION = 29,
    TREE_ARTIFACT_DIRECTORY_CREATION_FAILURE = 30,
    ACTION_OUTPUT_DIRECTORY_CREATION_FAILURE = 31,
    ACTION_FS_OUTPUT_DIRECTORY_CREATION_FAILURE = 32,
    ACTION_FS_OUT_ERR_DIRECTORY_CREATION_FAILURE = 33,
    NON_ACTION_EXECUTION_FAILURE = 34,
    CYCLE = 35,
    SOURCE_INPUT_MISSING = 36,
    UNEXPECTED_EXCEPTION = 37,
    SOURCE_INPUT_IO_EXCEPTION = 39,
    SYMLINK_TREE_DELETION_IO_EXCEPTION = 40,
  };

  ::bes::failure_details::Execution::Code code_;
  bool has_code_;

  Execution();
  Execution(const Execution&) = default;
  Execution(Execution&&) = default;
  Execution& operator=(const Execution&) = default;
  Execution& operator=(Execution&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Execution::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Execution::Code& value);
};  // struct Execution
struct ExecutionOptions {
  enum Code {
    EXECUTION_OPTIONS_UNKNOWN = 0,
    INVALID_STRATEGY = 3,
    REQUESTED_STRATEGY_INCOMPATIBLE_WITH_SANDBOXING = 4,
    DEPRECATED_LOCAL_RESOURCES_USED = 5,
    INVALID_CYCLIC_DYNAMIC_STRATEGY = 6,
    RESTRICTION_UNMATCHED_TO_ACTION_CONTEXT = 7,
    REMOTE_FALLBACK_STRATEGY_NOT_ABSTRACT_SPAWN = 8,
    STRATEGY_NOT_FOUND = 9,
    DYNAMIC_STRATEGY_NOT_SANDBOXED = 10,
    MULTIPLE_EXECUTION_LOG_FORMATS = 11,
  };

  ::bes::failure_details::ExecutionOptions::Code code_;
  bool has_code_;

  ExecutionOptions();
  ExecutionOptions(const ExecutionOptions&) = default;
  ExecutionOptions(ExecutionOptions&&) = default;
  ExecutionOptions& operator=(const ExecutionOptions&) = default;
  ExecutionOptions& operator=(ExecutionOptions&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ExecutionOptions::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ExecutionOptions::Code& value);
};  // struct ExecutionOptions
struct ExternalDeps {
  enum Code {
    EXTERNAL_DEPS_UNKNOWN = 0,
    MODULE_NOT_FOUND = 1,
    BAD_MODULE = 2,
    VERSION_RESOLUTION_ERROR = 3,
    INVALID_REGISTRY_URL = 4,
    ERROR_ACCESSING_REGISTRY = 5,
    INVALID_EXTENSION_IMPORT = 6,
    BAD_LOCKFILE = 7,
  };

  ::bes::failure_details::ExternalDeps::Code code_;
  bool has_code_;

  ExternalDeps();
  ExternalDeps(const ExternalDeps&) = default;
  ExternalDeps(ExternalDeps&&) = default;
  ExternalDeps& operator=(const ExternalDeps&) = default;
  ExternalDeps& operator=(ExternalDeps&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ExternalDeps::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ExternalDeps::Code& value);
};  // struct ExternalDeps
struct ExternalRepository {
  enum Code {
    EXTERNAL_REPOSITORY_UNKNOWN = 0,
    OVERRIDE_DISALLOWED_MANAGED_DIRECTORIES = 1,
    BAD_DOWNLOADER_CONFIG = 2,
    REPOSITORY_MAPPING_RESOLUTION_FAILED = 3,
    CREDENTIALS_INIT_FAILURE = 4,
  };

  ::bes::failure_details::ExternalRepository::Code code_;
  bool has_code_;

  ExternalRepository();
  ExternalRepository(const ExternalRepository&) = default;
  ExternalRepository(ExternalRepository&&) = default;
  ExternalRepository& operator=(const ExternalRepository&) = default;
  ExternalRepository& operator=(ExternalRepository&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ExternalRepository::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ExternalRepository::Code& value);
};  // struct ExternalRepository
struct FailAction {
  enum Code {
    FAIL_ACTION_UNKNOWN = 0,
    INTENTIONAL_FAILURE = 1,
    INCORRECT_PYTHON_VERSION = 2,
    PROGUARD_SPECS_MISSING = 3,
    DYNAMIC_LINKING_NOT_SUPPORTED = 4,
    SOURCE_FILES_MISSING = 5,
    INCORRECT_TOOLCHAIN = 6,
    FRAGMENT_CLASS_MISSING = 7,
    CANT_BUILD_INCOMPATIBLE_TARGET = 10,
  };

  ::bes::failure_details::FailAction::Code code_;
  bool has_code_;

  FailAction();
  FailAction(const FailAction&) = default;
  FailAction(FailAction&&) = default;
  FailAction& operator=(const FailAction&) = default;
  FailAction& operator=(FailAction&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::FailAction::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::FailAction::Code& value);
};  // struct FailAction
struct FetchCommand {
  enum Code {
    FETCH_COMMAND_UNKNOWN = 0,
    EXPRESSION_MISSING = 1,
    OPTIONS_INVALID = 2,
    QUERY_PARSE_ERROR = 3,
    QUERY_EVALUATION_ERROR = 4,
  };

  ::bes::failure_details::FetchCommand::Code code_;
  bool has_code_;

  FetchCommand();
  FetchCommand(const FetchCommand&) = default;
  FetchCommand(FetchCommand&&) = default;
  FetchCommand& operator=(const FetchCommand&) = default;
  FetchCommand& operator=(FetchCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::FetchCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::FetchCommand::Code& value);
};  // struct FetchCommand
struct Filesystem {
  enum Code {
    FILESYSTEM_UNKNOWN = 0,
    EMBEDDED_BINARIES_ENUMERATION_FAILURE = 3,
    SERVER_PID_TXT_FILE_READ_FAILURE = 4,
    SERVER_FILE_WRITE_FAILURE = 5,
    DEFAULT_DIGEST_HASH_FUNCTION_INVALID_VALUE = 6,
    FILESYSTEM_JNI_NOT_AVAILABLE = 8,
  };

  ::bes::failure_details::Filesystem::Code code_;
  bool has_code_;

  Filesystem();
  Filesystem(const Filesystem&) = default;
  Filesystem(Filesystem&&) = default;
  Filesystem& operator=(const Filesystem&) = default;
  Filesystem& operator=(Filesystem&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Filesystem::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Filesystem::Code& value);
};  // struct Filesystem
struct GrpcServer {
  enum Code {
    GRPC_SERVER_UNKNOWN = 0,
    GRPC_SERVER_NOT_COMPILED_IN = 1,
    SERVER_BIND_FAILURE = 2,
    BAD_COOKIE = 3,
    NO_CLIENT_DESCRIPTION = 4,
  };

  ::bes::failure_details::GrpcServer::Code code_;
  bool has_code_;

  GrpcServer();
  GrpcServer(const GrpcServer&) = default;
  GrpcServer(GrpcServer&&) = default;
  GrpcServer& operator=(const GrpcServer&) = default;
  GrpcServer& operator=(GrpcServer&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::GrpcServer::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::GrpcServer::Code& value);
};  // struct GrpcServer
struct HelpCommand {
  enum Code {
    HELP_COMMAND_UNKNOWN = 0,
    MISSING_ARGUMENT = 1,
    COMMAND_NOT_FOUND = 2,
  };

  ::bes::failure_details::HelpCommand::Code code_;
  bool has_code_;

  HelpCommand();
  HelpCommand(const HelpCommand&) = default;
  HelpCommand(HelpCommand&&) = default;
  HelpCommand& operator=(const HelpCommand&) = default;
  HelpCommand& operator=(HelpCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::HelpCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::HelpCommand::Code& value);
};  // struct HelpCommand
struct PackageLoading {
  enum Code {
    PACKAGE_LOADING_UNKNOWN = 0,
    WORKSPACE_FILE_ERROR = 1,
    MAX_COMPUTATION_STEPS_EXCEEDED = 2,
    BUILD_FILE_MISSING = 3,
    REPOSITORY_MISSING = 4,
    PERSISTENT_INCONSISTENT_FILESYSTEM_ERROR = 5,
    TRANSIENT_INCONSISTENT_FILESYSTEM_ERROR = 6,
    INVALID_NAME = 7,
    EVAL_GLOBS_SYMLINK_ERROR = 9,
    IMPORT_STARLARK_FILE_ERROR = 10,
    PACKAGE_MISSING = 11,
    TARGET_MISSING = 12,
    NO_SUCH_THING = 13,
    GLOB_IO_EXCEPTION = 14,
    DUPLICATE_LABEL = 15,
    INVALID_PACKAGE_SPECIFICATION = 16,
    SYNTAX_ERROR = 17,
    ENVIRONMENT_IN_DIFFERENT_PACKAGE = 18,
    DEFAULT_ENVIRONMENT_UNDECLARED = 19,
    ENVIRONMENT_IN_MULTIPLE_GROUPS = 20,
    ENVIRONMENT_DOES_NOT_EXIST = 21,
    ENVIRONMENT_INVALID = 22,
    ENVIRONMENT_NOT_IN_GROUP = 23,
    PACKAGE_NAME_INVALID = 24,
    STARLARK_EVAL_ERROR = 25,
    LICENSE_PARSE_FAILURE = 26,
    DISTRIBUTIONS_PARSE_FAILURE = 27,
    LABEL_CROSSES_PACKAGE_BOUNDARY = 28,
    BUILTINS_INJECTION_FAILURE = 29,
    SYMLINK_CYCLE_OR_INFINITE_EXPANSION = 30,
    OTHER_IO_EXCEPTION = 31,
    BAD_REPO_FILE = 32,
  };

  ::bes::failure_details::PackageLoading::Code code_;
  bool has_code_;

  PackageLoading();
  PackageLoading(const PackageLoading&) = default;
  PackageLoading(PackageLoading&&) = default;
  PackageLoading& operator=(const PackageLoading&) = default;
  PackageLoading& operator=(PackageLoading&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::PackageLoading::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::PackageLoading::Code& value);
};  // struct PackageLoading
struct IncludeScanning {
  enum Code {
    INCLUDE_SCANNING_UNKNOWN = 0,
    INITIALIZE_INCLUDE_HINTS_ERROR = 1,
    SCANNING_IO_EXCEPTION = 2,
    INCLUDE_HINTS_FILE_NOT_IN_PACKAGE = 3,
    INCLUDE_HINTS_READ_FAILURE = 4,
    ILLEGAL_ABSOLUTE_PATH = 5,
    PACKAGE_LOAD_FAILURE = 6,
    USER_PACKAGE_LOAD_FAILURE = 7,
    SYSTEM_PACKAGE_LOAD_FAILURE = 8,
    UNDIFFERENTIATED_PACKAGE_LOAD_FAILURE = 9,
  };

  ::bes::failure_details::IncludeScanning::Code code_;
  bool has_code_;
  ::bes::failure_details::PackageLoading::Code package_loading_code_;
  bool has_package_loading_code_;

  IncludeScanning();
  IncludeScanning(const IncludeScanning&) = default;
  IncludeScanning(IncludeScanning&&) = default;
  IncludeScanning& operator=(const IncludeScanning&) = default;
  IncludeScanning& operator=(IncludeScanning&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::IncludeScanning::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::IncludeScanning::Code& value);
  ::bes::failure_details::PackageLoading::Code* mutable_package_loading_code() {
    has_package_loading_code_ = true;
    return &package_loading_code_;
  }
  void set_package_loading_code(const ::bes::failure_details::PackageLoading::Code& value);
};  // struct IncludeScanning
struct InfoCommand {
  enum Code {
    INFO_COMMAND_UNKNOWN = 0,
    TOO_MANY_KEYS = 1,
    KEY_NOT_RECOGNIZED = 2,
    INFO_BLOCK_WRITE_FAILURE = 3,
    ALL_INFO_WRITE_FAILURE = 4,
  };

  ::bes::failure_details::InfoCommand::Code code_;
  bool has_code_;

  InfoCommand();
  InfoCommand(const InfoCommand&) = default;
  InfoCommand(InfoCommand&&) = default;
  InfoCommand& operator=(const InfoCommand&) = default;
  InfoCommand& operator=(InfoCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::InfoCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::InfoCommand::Code& value);
};  // struct InfoCommand
struct Interrupted {
  enum Code {
    INTERRUPTED_UNKNOWN = 0,
    INTERRUPTED = 28,
    DEPRECATED_BUILD = 4,
    DEPRECATED_BUILD_COMPLETION = 5,
    DEPRECATED_PACKAGE_LOADING_SYNC = 6,
    DEPRECATED_EXECUTOR_COMPLETION = 7,
    DEPRECATED_COMMAND_DISPATCH = 8,
    DEPRECATED_INFO_ITEM = 9,
    DEPRECATED_AFTER_QUERY = 10,
    DEPRECATED_FETCH_COMMAND = 17,
    DEPRECATED_SYNC_COMMAND = 18,
    DEPRECATED_CLEAN_COMMAND = 20,
    DEPRECATED_MOBILE_INSTALL_COMMAND = 21,
    DEPRECATED_QUERY = 22,
    DEPRECATED_RUN_COMMAND = 23,
    DEPRECATED_OPTIONS_PARSING = 27,
  };

  ::bes::failure_details::Interrupted::Code code_;
  bool has_code_;

  Interrupted();
  Interrupted(const Interrupted&) = default;
  Interrupted(Interrupted&&) = default;
  Interrupted& operator=(const Interrupted&) = default;
  Interrupted& operator=(Interrupted&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Interrupted::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Interrupted::Code& value);
};  // struct Interrupted
struct JavaCompile {
  enum Code {
    JAVA_COMPILE_UNKNOWN = 0,
    REDUCED_CLASSPATH_FAILURE = 1,
    COMMAND_LINE_EXPANSION_FAILURE = 2,
    JDEPS_READ_IO_EXCEPTION = 3,
    REDUCED_CLASSPATH_FALLBACK_CLEANUP_FAILURE = 4,
  };

  ::bes::failure_details::JavaCompile::Code code_;
  bool has_code_;

  JavaCompile();
  JavaCompile(const JavaCompile&) = default;
  JavaCompile(JavaCompile&&) = default;
  JavaCompile& operator=(const JavaCompile&) = default;
  JavaCompile& operator=(JavaCompile&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::JavaCompile::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::JavaCompile::Code& value);
};  // struct JavaCompile
struct LocalExecution {
  enum Code {
    LOCAL_EXECUTION_UNKNOWN = 0,
    LOCKFREE_OUTPUT_PREREQ_UNMET = 1,
    UNTRACKED_RESOURCE = 2,
  };

  ::bes::failure_details::LocalExecution::Code code_;
  bool has_code_;

  LocalExecution();
  LocalExecution(const LocalExecution&) = default;
  LocalExecution(LocalExecution&&) = default;
  LocalExecution& operator=(const LocalExecution&) = default;
  LocalExecution& operator=(LocalExecution&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::LocalExecution::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::LocalExecution::Code& value);
};  // struct LocalExecution
struct LtoAction {
  enum Code {
    LTO_ACTION_UNKNOWN = 0,
    INVALID_ABSOLUTE_PATH_IN_IMPORTS = 1,
    MISSING_BITCODE_FILES = 2,
    IMPORTS_READ_IO_EXCEPTION = 3,
  };

  ::bes::failure_details::LtoAction::Code code_;
  bool has_code_;

  LtoAction();
  LtoAction(const LtoAction&) = default;
  LtoAction(LtoAction&&) = default;
  LtoAction& operator=(const LtoAction&) = default;
  LtoAction& operator=(LtoAction&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::LtoAction::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::LtoAction::Code& value);
};  // struct LtoAction
struct MemoryOptions {
  enum Code {
    MEMORY_OPTIONS_UNKNOWN = 0,
    DEPRECATED_EXPERIMENTAL_OOM_MORE_EAGERLY_THRESHOLD_INVALID_VALUE = 1,
    DEPRECATED_EXPERIMENTAL_OOM_MORE_EAGERLY_NO_TENURED_COLLECTORS_FOUND = 2,
  };

  ::bes::failure_details::MemoryOptions::Code code_;
  bool has_code_;

  MemoryOptions();
  MemoryOptions(const MemoryOptions&) = default;
  MemoryOptions(MemoryOptions&&) = default;
  MemoryOptions& operator=(const MemoryOptions&) = default;
  MemoryOptions& operator=(MemoryOptions&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::MemoryOptions::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::MemoryOptions::Code& value);
};  // struct MemoryOptions
struct MobileInstall {
  enum Code {
    MOBILE_INSTALL_UNKNOWN = 0,
    CLASSIC_UNSUPPORTED = 1,
    NO_TARGET_SPECIFIED = 2,
    MULTIPLE_TARGETS_SPECIFIED = 3,
    TARGET_TYPE_INVALID = 4,
    NON_ZERO_EXIT = 5,
    ERROR_RUNNING_PROGRAM = 6,
  };

  ::bes::failure_details::MobileInstall::Code code_;
  bool has_code_;

  MobileInstall();
  MobileInstall(const MobileInstall&) = default;
  MobileInstall(MobileInstall&&) = default;
  MobileInstall& operator=(const MobileInstall&) = default;
  MobileInstall& operator=(MobileInstall&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::MobileInstall::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::MobileInstall::Code& value);
};  // struct MobileInstall
struct ModCommand {
  enum Code {
    MOD_COMMAND_UNKNOWN = 0,
    MISSING_ARGUMENTS = 1,
    TOO_MANY_ARGUMENTS = 2,
    INVALID_ARGUMENTS = 3,
    BUILDOZER_FAILED = 4,
    ERROR_DURING_GRAPH_INSPECTION = 5,
  };

  ::bes::failure_details::ModCommand::Code code_;
  bool has_code_;

  ModCommand();
  ModCommand(const ModCommand&) = default;
  ModCommand(ModCommand&&) = default;
  ModCommand& operator=(const ModCommand&) = default;
  ModCommand& operator=(ModCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ModCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ModCommand::Code& value);
};  // struct ModCommand
struct NinjaAction {
  enum Code {
    NINJA_ACTION_UNKNOWN = 0,
    INVALID_DEPFILE_DECLARED_DEPENDENCY = 1,
    D_FILE_PARSE_FAILURE = 2,
  };

  ::bes::failure_details::NinjaAction::Code code_;
  bool has_code_;

  NinjaAction();
  NinjaAction(const NinjaAction&) = default;
  NinjaAction(NinjaAction&&) = default;
  NinjaAction& operator=(const NinjaAction&) = default;
  NinjaAction& operator=(NinjaAction&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::NinjaAction::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::NinjaAction::Code& value);
};  // struct NinjaAction
struct PackageOptions {
  enum Code {
    PACKAGE_OPTIONS_UNKNOWN = 0,
    PACKAGE_PATH_INVALID = 1,
    NONSINGLETON_PACKAGE_PATH = 4,
  };

  ::bes::failure_details::PackageOptions::Code code_;
  bool has_code_;

  PackageOptions();
  PackageOptions(const PackageOptions&) = default;
  PackageOptions(PackageOptions&&) = default;
  PackageOptions& operator=(const PackageOptions&) = default;
  PackageOptions& operator=(PackageOptions&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::PackageOptions::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::PackageOptions::Code& value);
};  // struct PackageOptions
struct PrintActionCommand {
  enum Code {
    PRINT_ACTION_COMMAND_UNKNOWN = 0,
    TARGET_NOT_FOUND = 1,
    COMMAND_LINE_EXPANSION_FAILURE = 2,
    TARGET_KIND_UNSUPPORTED = 3,
    ACTIONS_NOT_FOUND = 4,
  };

  ::bes::failure_details::PrintActionCommand::Code code_;
  bool has_code_;

  PrintActionCommand();
  PrintActionCommand(const PrintActionCommand&) = default;
  PrintActionCommand(PrintActionCommand&&) = default;
  PrintActionCommand& operator=(const PrintActionCommand&) = default;
  PrintActionCommand& operator=(PrintActionCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::PrintActionCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::PrintActionCommand::Code& value);
};  // struct PrintActionCommand
struct ProfileCommand {
  enum Code {
    PROFILE_COMMAND_UNKNOWN = 0,
    OLD_BINARY_FORMAT_UNSUPPORTED = 1,
    FILE_READ_FAILURE = 2,
  };

  ::bes::failure_details::ProfileCommand::Code code_;
  bool has_code_;

  ProfileCommand();
  ProfileCommand(const ProfileCommand&) = default;
  ProfileCommand(ProfileCommand&&) = default;
  ProfileCommand& operator=(const ProfileCommand&) = default;
  ProfileCommand& operator=(ProfileCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::ProfileCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::ProfileCommand::Code& value);
};  // struct ProfileCommand
struct Query {
  enum Code {
    QUERY_UNKNOWN = 0,
    QUERY_FILE_WITH_COMMAND_LINE_EXPRESSION = 1,
    QUERY_FILE_READ_FAILURE = 2,
    COMMAND_LINE_EXPRESSION_MISSING = 3,
    OUTPUT_FORMAT_INVALID = 4,
    GRAPHLESS_PREREQ_UNMET = 5,
    QUERY_OUTPUT_WRITE_FAILURE = 6,
    QUERY_STDOUT_FLUSH_FAILURE = 13,
    ANALYSIS_QUERY_PREREQ_UNMET = 14,
    QUERY_RESULTS_FLUSH_FAILURE = 15,
    DEPRECATED_UNCLOSED_QUOTATION_EXPRESSION_ERROR = 16,
    VARIABLE_NAME_INVALID = 17,
    VARIABLE_UNDEFINED = 18,
    BUILDFILES_AND_LOADFILES_CANNOT_USE_OUTPUT_LOCATION_ERROR = 19,
    BUILD_FILE_ERROR = 20,
    CYCLE = 21,
    UNIQUE_SKYKEY_THRESHOLD_EXCEEDED = 22,
    TARGET_NOT_IN_UNIVERSE_SCOPE = 23,
    INVALID_FULL_UNIVERSE_EXPRESSION = 24,
    UNIVERSE_SCOPE_LIMIT_EXCEEDED = 25,
    INVALIDATION_LIMIT_EXCEEDED = 26,
    OUTPUT_FORMAT_PREREQ_UNMET = 27,
    ARGUMENTS_MISSING = 28,
    RBUILDFILES_FUNCTION_REQUIRES_SKYQUERY = 29,
    FULL_TARGETS_NOT_SUPPORTED = 30,
    DEPRECATED_UNEXPECTED_TOKEN_ERROR = 31,
    DEPRECATED_INTEGER_LITERAL_MISSING = 32,
    DEPRECATED_INVALID_STARTING_CHARACTER_ERROR = 33,
    DEPRECATED_PREMATURE_END_OF_INPUT_ERROR = 34,
    SYNTAX_ERROR = 35,
    OUTPUT_FORMATTER_IO_EXCEPTION = 36,
    SKYQUERY_TRANSITIVE_TARGET_ERROR = 37,
    SKYQUERY_TARGET_EXCEPTION = 38,
    INVALID_LABEL_IN_TEST_SUITE = 39,
    ILLEGAL_FLAG_COMBINATION = 40,
    NON_DETAILED_ERROR = 41,
  };

  ::bes::failure_details::Query::Code code_;
  bool has_code_;

  Query();
  Query(const Query&) = default;
  Query(Query&&) = default;
  Query& operator=(const Query&) = default;
  Query& operator=(Query&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Query::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Query::Code& value);
};  // struct Query
struct RemoteAnalysisCaching {
  enum Code {
    REMOTE_ANALYSIS_CACHING_UNKNOWN = 0,
    SERIALIZED_FRONTIER_PROFILE_FAILED = 1,
    PROJECT_FILE_NOT_FOUND = 2,
  };

  ::bes::failure_details::RemoteAnalysisCaching::Code code_;
  bool has_code_;

  RemoteAnalysisCaching();
  RemoteAnalysisCaching(const RemoteAnalysisCaching&) = default;
  RemoteAnalysisCaching(RemoteAnalysisCaching&&) = default;
  RemoteAnalysisCaching& operator=(const RemoteAnalysisCaching&) = default;
  RemoteAnalysisCaching& operator=(RemoteAnalysisCaching&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::RemoteAnalysisCaching::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::RemoteAnalysisCaching::Code& value);
};  // struct RemoteAnalysisCaching
struct RemoteExecution {
  enum Code {
    REMOTE_EXECUTION_UNKNOWN = 0,
    CAPABILITIES_QUERY_FAILURE = 1,
    CREDENTIALS_INIT_FAILURE = 2,
    CACHE_INIT_FAILURE = 3,
    RPC_LOG_FAILURE = 4,
    EXEC_CHANNEL_INIT_FAILURE = 5,
    CACHE_CHANNEL_INIT_FAILURE = 6,
    DOWNLOADER_CHANNEL_INIT_FAILURE = 7,
    LOG_DIR_CLEANUP_FAILURE = 8,
    CLIENT_SERVER_INCOMPATIBLE = 9,
    DOWNLOADED_INPUTS_DELETION_FAILURE = 10,
    REMOTE_DOWNLOAD_OUTPUTS_MINIMAL_WITHOUT_INMEMORY_DOTD = 11,
    REMOTE_DOWNLOAD_OUTPUTS_MINIMAL_WITHOUT_INMEMORY_JDEPS = 12,
    INCOMPLETE_OUTPUT_DOWNLOAD_CLEANUP_FAILURE = 13,
    REMOTE_DEFAULT_PLATFORM_PROPERTIES_PARSE_FAILURE = 14,
    ILLEGAL_OUTPUT = 15,
    INVALID_EXEC_AND_PLATFORM_PROPERTIES = 16,
    TOPLEVEL_OUTPUTS_DOWNLOAD_FAILURE = 17,
  };

  ::bes::failure_details::RemoteExecution::Code code_;
  bool has_code_;

  RemoteExecution();
  RemoteExecution(const RemoteExecution&) = default;
  RemoteExecution(RemoteExecution&&) = default;
  RemoteExecution& operator=(const RemoteExecution&) = default;
  RemoteExecution& operator=(RemoteExecution&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::RemoteExecution::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::RemoteExecution::Code& value);
};  // struct RemoteExecution
struct RemoteOptions {
  enum Code {
    REMOTE_OPTIONS_UNKNOWN = 0,
    REMOTE_DEFAULT_EXEC_PROPERTIES_LOGIC_ERROR = 1,
    CREDENTIALS_READ_FAILURE = 2,
    CREDENTIALS_WRITE_FAILURE = 3,
    DOWNLOADER_WITHOUT_GRPC_CACHE = 4,
    EXECUTION_WITH_INVALID_CACHE = 5,
  };

  ::bes::failure_details::RemoteOptions::Code code_;
  bool has_code_;

  RemoteOptions();
  RemoteOptions(const RemoteOptions&) = default;
  RemoteOptions(RemoteOptions&&) = default;
  RemoteOptions& operator=(const RemoteOptions&) = default;
  RemoteOptions& operator=(RemoteOptions&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::RemoteOptions::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::RemoteOptions::Code& value);
};  // struct RemoteOptions
struct RunCommand {
  enum Code {
    RUN_COMMAND_UNKNOWN = 0,
    NO_TARGET_SPECIFIED = 1,
    TOO_MANY_TARGETS_SPECIFIED = 2,
    TARGET_NOT_EXECUTABLE = 3,
    TARGET_BUILT_BUT_PATH_NOT_EXECUTABLE = 4,
    TARGET_BUILT_BUT_PATH_VALIDATION_FAILED = 5,
    RUN_UNDER_TARGET_NOT_BUILT = 6,
    RUN_PREREQ_UNMET = 7,
    TOO_MANY_TEST_SHARDS_OR_RUNS = 8,
    TEST_ENVIRONMENT_SETUP_FAILURE = 9,
    COMMAND_LINE_EXPANSION_FAILURE = 10,
    NO_SHELL_SPECIFIED = 11,
    SCRIPT_WRITE_FAILURE = 12,
    RUNFILES_DIRECTORIES_CREATION_FAILURE = 13,
    RUNFILES_SYMLINKS_CREATION_FAILURE = 14,
    TEST_ENVIRONMENT_SETUP_INTERRUPTED = 15,
  };

  ::bes::failure_details::RunCommand::Code code_;
  bool has_code_;

  RunCommand();
  RunCommand(const RunCommand&) = default;
  RunCommand(RunCommand&&) = default;
  RunCommand& operator=(const RunCommand&) = default;
  RunCommand& operator=(RunCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::RunCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::RunCommand::Code& value);
};  // struct RunCommand
struct Sandbox {
  enum Code {
    SANDBOX_FAILURE_UNKNOWN = 0,
    INITIALIZATION_FAILURE = 1,
    EXECUTION_IO_EXCEPTION = 2,
    DOCKER_COMMAND_FAILURE = 3,
    NO_DOCKER_IMAGE = 4,
    DOCKER_IMAGE_PREPARATION_FAILURE = 5,
    BIND_MOUNT_ANALYSIS_FAILURE = 6,
    MOUNT_SOURCE_DOES_NOT_EXIST = 7,
    MOUNT_SOURCE_TARGET_TYPE_MISMATCH = 8,
    MOUNT_TARGET_DOES_NOT_EXIST = 9,
    SUBPROCESS_START_FAILED = 10,
    FORBIDDEN_INPUT = 11,
    COPY_INPUTS_IO_EXCEPTION = 12,
    COPY_OUTPUTS_IO_EXCEPTION = 13,
  };

  ::bes::failure_details::Sandbox::Code code_;
  bool has_code_;

  Sandbox();
  Sandbox(const Sandbox&) = default;
  Sandbox(Sandbox&&) = default;
  Sandbox& operator=(const Sandbox&) = default;
  Sandbox& operator=(Sandbox&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Sandbox::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Sandbox::Code& value);
};  // struct Sandbox
struct Skyfocus {
  enum Code {
    INVALID_WORKING_SET = 0,
    NON_WORKING_SET_CHANGE = 1,
    CONFIGURATION_CHANGE = 2,
    DISALLOWED_OPERATION_ON_FOCUSED_GRAPH = 3,
  };

  ::bes::failure_details::Skyfocus::Code code_;
  bool has_code_;

  Skyfocus();
  Skyfocus(const Skyfocus&) = default;
  Skyfocus(Skyfocus&&) = default;
  Skyfocus& operator=(const Skyfocus&) = default;
  Skyfocus& operator=(Skyfocus&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Skyfocus::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Skyfocus::Code& value);
};  // struct Skyfocus
struct Spawn {
  enum Code {
    SPAWN_UNKNOWN = 0,
    NON_ZERO_EXIT = 1,
    TIMEOUT = 2,
    OUT_OF_MEMORY = 3,
    EXECUTION_FAILED = 4,
    EXECUTION_DENIED = 5,
    REMOTE_CACHE_FAILED = 6,
    COMMAND_LINE_EXPANSION_FAILURE = 7,
    EXEC_IO_EXCEPTION = 8,
    INVALID_TIMEOUT = 9,
    INVALID_REMOTE_EXECUTION_PROPERTIES = 10,
    NO_USABLE_STRATEGY_FOUND = 11,
    UNSPECIFIED_EXECUTION_FAILURE = 12,
    FORBIDDEN_INPUT = 13,
    REMOTE_CACHE_EVICTED = 14,
    SPAWN_LOG_IO_EXCEPTION = 15,
  };

  ::bes::failure_details::Spawn::Code code_;
  bool has_code_;
  bool catastrophic_;
  bool has_catastrophic_;
  int32_t spawn_exit_code_;
  bool has_spawn_exit_code_;

  Spawn();
  Spawn(const Spawn&) = default;
  Spawn(Spawn&&) = default;
  Spawn& operator=(const Spawn&) = default;
  Spawn& operator=(Spawn&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Spawn::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Spawn::Code& value);
  bool* mutable_catastrophic() {
    has_catastrophic_ = true;
    return &catastrophic_;
  }
  void set_catastrophic(const bool& value);
  int32_t* mutable_spawn_exit_code() {
    has_spawn_exit_code_ = true;
    return &spawn_exit_code_;
  }
  void set_spawn_exit_code(const int32_t& value);
};  // struct Spawn
struct StarlarkAction {
  enum Code {
    STARLARK_ACTION_UNKNOWN = 0,
    UNUSED_INPUT_LIST_READ_FAILURE = 1,
    UNUSED_INPUT_LIST_FILE_NOT_FOUND = 2,
  };

  ::bes::failure_details::StarlarkAction::Code code_;
  bool has_code_;

  StarlarkAction();
  StarlarkAction(const StarlarkAction&) = default;
  StarlarkAction(StarlarkAction&&) = default;
  StarlarkAction& operator=(const StarlarkAction&) = default;
  StarlarkAction& operator=(StarlarkAction&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::StarlarkAction::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::StarlarkAction::Code& value);
};  // struct StarlarkAction
struct StarlarkLoading {
  enum Code {
    STARLARK_LOADING_UNKNOWN = 0,
    CYCLE = 1,
    COMPILE_ERROR = 2,
    PARSE_ERROR = 3,
    EVAL_ERROR = 4,
    CONTAINING_PACKAGE_NOT_FOUND = 5,
    PACKAGE_NOT_FOUND = 6,
    IO_ERROR = 7,
    LABEL_CROSSES_PACKAGE_BOUNDARY = 8,
    BUILTINS_ERROR = 9,
    VISIBILITY_ERROR = 10,
  };

  ::bes::failure_details::StarlarkLoading::Code code_;
  bool has_code_;

  StarlarkLoading();
  StarlarkLoading(const StarlarkLoading&) = default;
  StarlarkLoading(StarlarkLoading&&) = default;
  StarlarkLoading& operator=(const StarlarkLoading&) = default;
  StarlarkLoading& operator=(StarlarkLoading&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::StarlarkLoading::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::StarlarkLoading::Code& value);
};  // struct StarlarkLoading
struct SymlinkAction {
  enum Code {
    SYMLINK_ACTION_UNKNOWN = 0,
    EXECUTABLE_INPUT_NOT_FILE = 1,
    EXECUTABLE_INPUT_IS_NOT = 2,
    EXECUTABLE_INPUT_CHECK_IO_EXCEPTION = 3,
    LINK_CREATION_IO_EXCEPTION = 4,
    LINK_TOUCH_IO_EXCEPTION = 5,
    LINK_LOG_IO_EXCEPTION = 6,
  };

  ::bes::failure_details::SymlinkAction::Code code_;
  bool has_code_;

  SymlinkAction();
  SymlinkAction(const SymlinkAction&) = default;
  SymlinkAction(SymlinkAction&&) = default;
  SymlinkAction& operator=(const SymlinkAction&) = default;
  SymlinkAction& operator=(SymlinkAction&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::SymlinkAction::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::SymlinkAction::Code& value);
};  // struct SymlinkAction
struct SymlinkForest {
  enum Code {
    SYMLINK_FOREST_UNKNOWN = 0,
    TOPLEVEL_OUTDIR_PACKAGE_PATH_CONFLICT = 1,
    TOPLEVEL_OUTDIR_USED_AS_SOURCE = 2,
    CREATION_FAILED = 3,
  };

  ::bes::failure_details::SymlinkForest::Code code_;
  bool has_code_;

  SymlinkForest();
  SymlinkForest(const SymlinkForest&) = default;
  SymlinkForest(SymlinkForest&&) = default;
  SymlinkForest& operator=(const SymlinkForest&) = default;
  SymlinkForest& operator=(SymlinkForest&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::SymlinkForest::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::SymlinkForest::Code& value);
};  // struct SymlinkForest
struct SyncCommand {
  enum Code {
    SYNC_COMMAND_UNKNOWN = 0,
    PACKAGE_LOOKUP_ERROR = 1,
    WORKSPACE_EVALUATION_ERROR = 2,
    REPOSITORY_FETCH_ERRORS = 3,
    REPOSITORY_NAME_INVALID = 4,
  };

  ::bes::failure_details::SyncCommand::Code code_;
  bool has_code_;

  SyncCommand();
  SyncCommand(const SyncCommand&) = default;
  SyncCommand(SyncCommand&&) = default;
  SyncCommand& operator=(const SyncCommand&) = default;
  SyncCommand& operator=(SyncCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::SyncCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::SyncCommand::Code& value);
};  // struct SyncCommand
struct TargetPatterns {
  enum Code {
    TARGET_PATTERNS_UNKNOWN = 0,
    TARGET_PATTERN_FILE_WITH_COMMAND_LINE_PATTERN = 1,
    TARGET_PATTERN_FILE_READ_FAILURE = 2,
    TARGET_PATTERN_PARSE_FAILURE = 3,
    PACKAGE_NOT_FOUND = 4,
    TARGET_FORMAT_INVALID = 5,
    ABSOLUTE_TARGET_PATTERN_INVALID = 6,
    CANNOT_DETERMINE_TARGET_FROM_FILENAME = 7,
    LABEL_SYNTAX_ERROR = 8,
    TARGET_CANNOT_BE_EMPTY_STRING = 9,
    PACKAGE_PART_CANNOT_END_IN_SLASH = 10,
    CYCLE = 11,
    CANNOT_PRELOAD_TARGET = 12,
    TARGETS_MISSING = 13,
    RECURSIVE_TARGET_PATTERNS_NOT_ALLOWED = 14,
    UP_LEVEL_REFERENCES_NOT_ALLOWED = 15,
    NEGATIVE_TARGET_PATTERN_NOT_ALLOWED = 16,
    TARGET_MUST_BE_A_FILE = 17,
    DEPENDENCY_NOT_FOUND = 18,
    PACKAGE_NAME_INVALID = 19,
  };

  ::bes::failure_details::TargetPatterns::Code code_;
  bool has_code_;

  TargetPatterns();
  TargetPatterns(const TargetPatterns&) = default;
  TargetPatterns(TargetPatterns&&) = default;
  TargetPatterns& operator=(const TargetPatterns&) = default;
  TargetPatterns& operator=(TargetPatterns&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::TargetPatterns::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::TargetPatterns::Code& value);
};  // struct TargetPatterns
struct TestAction {
  enum Code {
    TEST_ACTION_UNKNOWN = 0,
    NO_KEEP_GOING_TEST_FAILURE = 1,
    LOCAL_TEST_PREREQ_UNMET = 2,
    COMMAND_LINE_EXPANSION_FAILURE = 3,
    DUPLICATE_CPU_TAGS = 4,
    INVALID_CPU_TAG = 5,
  };

  ::bes::failure_details::TestAction::Code code_;
  bool has_code_;

  TestAction();
  TestAction(const TestAction&) = default;
  TestAction(TestAction&&) = default;
  TestAction& operator=(const TestAction&) = default;
  TestAction& operator=(TestAction&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::TestAction::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::TestAction::Code& value);
};  // struct TestAction
struct TestCommand {
  enum Code {
    TEST_COMMAND_UNKNOWN = 0,
    NO_TEST_TARGETS = 1,
    TEST_WITH_NOANALYZE = 2,
    TESTS_FAILED = 3,
  };

  ::bes::failure_details::TestCommand::Code code_;
  bool has_code_;

  TestCommand();
  TestCommand(const TestCommand&) = default;
  TestCommand(TestCommand&&) = default;
  TestCommand& operator=(const TestCommand&) = default;
  TestCommand& operator=(TestCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::TestCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::TestCommand::Code& value);
};  // struct TestCommand
struct Toolchain {
  enum Code {
    TOOLCHAIN_UNKNOWN = 0,
    MISSING_PROVIDER = 1,
    INVALID_CONSTRAINT_VALUE = 2,
    INVALID_PLATFORM_VALUE = 3,
    INVALID_TOOLCHAIN = 4,
    NO_MATCHING_EXECUTION_PLATFORM = 5,
    NO_MATCHING_TOOLCHAIN = 6,
    INVALID_TOOLCHAIN_TYPE = 7,
  };

  ::bes::failure_details::Toolchain::Code code_;
  bool has_code_;

  Toolchain();
  Toolchain(const Toolchain&) = default;
  Toolchain(Toolchain&&) = default;
  Toolchain& operator=(const Toolchain&) = default;
  Toolchain& operator=(Toolchain&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Toolchain::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Toolchain::Code& value);
};  // struct Toolchain
struct VersionCommand {
  enum Code {
    VERSION_COMMAND_UNKNOWN = 0,
    NOT_AVAILABLE = 1,
  };

  ::bes::failure_details::VersionCommand::Code code_;
  bool has_code_;

  VersionCommand();
  VersionCommand(const VersionCommand&) = default;
  VersionCommand(VersionCommand&&) = default;
  VersionCommand& operator=(const VersionCommand&) = default;
  VersionCommand& operator=(VersionCommand&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::VersionCommand::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::VersionCommand::Code& value);
};  // struct VersionCommand
struct Worker {
  enum Code {
    WORKER_UNKNOWN = 0,
    MULTIPLEXER_INSTANCE_REMOVAL_FAILURE = 1,
    MULTIPLEXER_DOES_NOT_EXIST = 2,
    NO_TOOLS = 3,
    NO_FLAGFILE = 4,
    VIRTUAL_INPUT_MATERIALIZATION_FAILURE = 5,
    BORROW_FAILURE = 6,
    PREFETCH_FAILURE = 7,
    PREPARE_FAILURE = 8,
    REQUEST_FAILURE = 9,
    PARSE_RESPONSE_FAILURE = 10,
    NO_RESPONSE = 11,
    FINISH_FAILURE = 12,
    FORBIDDEN_INPUT = 13,
  };

  ::bes::failure_details::Worker::Code code_;
  bool has_code_;

  Worker();
  Worker(const Worker&) = default;
  Worker(Worker&&) = default;
  Worker& operator=(const Worker&) = default;
  Worker& operator=(Worker&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Worker::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Worker::Code& value);
};  // struct Worker
struct WorkspaceStatus {
  enum Code {
    WORKSPACE_STATUS_UNKNOWN = 0,
    NON_ZERO_EXIT = 1,
    ABNORMAL_TERMINATION = 2,
    EXEC_FAILED = 3,
    PARSE_FAILURE = 4,
    VALIDATION_FAILURE = 5,
    CONTENT_UPDATE_IO_EXCEPTION = 6,
    STDERR_IO_EXCEPTION = 7,
  };

  ::bes::failure_details::WorkspaceStatus::Code code_;
  bool has_code_;

  WorkspaceStatus();
  WorkspaceStatus(const WorkspaceStatus&) = default;
  WorkspaceStatus(WorkspaceStatus&&) = default;
  WorkspaceStatus& operator=(const WorkspaceStatus&) = default;
  WorkspaceStatus& operator=(WorkspaceStatus&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::WorkspaceStatus::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::WorkspaceStatus::Code& value);
};  // struct WorkspaceStatus
struct Workspaces {
  enum Code {
    WORKSPACES_UNKNOWN = 0,
    WORKSPACES_LOG_INITIALIZATION_FAILURE = 1,
    WORKSPACES_LOG_WRITE_FAILURE = 2,
    ILLEGAL_WORKSPACE_FILE_SYMLINK_WITH_MANAGED_DIRECTORIES = 3,
    WORKSPACE_FILE_READ_FAILURE_WITH_MANAGED_DIRECTORIES = 4,
  };

  ::bes::failure_details::Workspaces::Code code_;
  bool has_code_;

  Workspaces();
  Workspaces(const Workspaces&) = default;
  Workspaces(Workspaces&&) = default;
  Workspaces& operator=(const Workspaces&) = default;
  Workspaces& operator=(Workspaces&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::failure_details::Workspaces::Code* mutable_code() {
    has_code_ = true;
    return &code_;
  }
  void set_code(const ::bes::failure_details::Workspaces::Code& value);
};  // struct Workspaces
struct FailureDetail {
  std::string message_;
  bool has_message_;
  ::bes::failure_details::Interrupted interrupted_;
  bool has_interrupted_;
  ::bes::failure_details::ExternalRepository external_repository_;
  bool has_external_repository_;
  ::bes::failure_details::BuildProgress build_progress_;
  bool has_build_progress_;
  ::bes::failure_details::RemoteOptions remote_options_;
  bool has_remote_options_;
  ::bes::failure_details::ClientEnvironment client_environment_;
  bool has_client_environment_;
  ::bes::failure_details::Crash crash_;
  bool has_crash_;
  ::bes::failure_details::SymlinkForest symlink_forest_;
  bool has_symlink_forest_;
  ::bes::failure_details::PackageOptions package_options_;
  bool has_package_options_;
  ::bes::failure_details::RemoteExecution remote_execution_;
  bool has_remote_execution_;
  ::bes::failure_details::Execution execution_;
  bool has_execution_;
  ::bes::failure_details::Workspaces workspaces_;
  bool has_workspaces_;
  ::bes::failure_details::CrashOptions crash_options_;
  bool has_crash_options_;
  ::bes::failure_details::Filesystem filesystem_;
  bool has_filesystem_;
  ::bes::failure_details::ExecutionOptions execution_options_;
  bool has_execution_options_;
  ::bes::failure_details::Command command_;
  bool has_command_;
  ::bes::failure_details::Spawn spawn_;
  bool has_spawn_;
  ::bes::failure_details::GrpcServer grpc_server_;
  bool has_grpc_server_;
  ::bes::failure_details::CanonicalizeFlags canonicalize_flags_;
  bool has_canonicalize_flags_;
  ::bes::failure_details::BuildConfiguration build_configuration_;
  bool has_build_configuration_;
  ::bes::failure_details::InfoCommand info_command_;
  bool has_info_command_;
  ::bes::failure_details::MemoryOptions memory_options_;
  bool has_memory_options_;
  ::bes::failure_details::Query query_;
  bool has_query_;
  ::bes::failure_details::LocalExecution local_execution_;
  bool has_local_execution_;
  ::bes::failure_details::ActionCache action_cache_;
  bool has_action_cache_;
  ::bes::failure_details::FetchCommand fetch_command_;
  bool has_fetch_command_;
  ::bes::failure_details::SyncCommand sync_command_;
  bool has_sync_command_;
  ::bes::failure_details::Sandbox sandbox_;
  bool has_sandbox_;
  ::bes::failure_details::IncludeScanning include_scanning_;
  bool has_include_scanning_;
  ::bes::failure_details::TestCommand test_command_;
  bool has_test_command_;
  ::bes::failure_details::ActionQuery action_query_;
  bool has_action_query_;
  ::bes::failure_details::TargetPatterns target_patterns_;
  bool has_target_patterns_;
  ::bes::failure_details::CleanCommand clean_command_;
  bool has_clean_command_;
  ::bes::failure_details::ConfigCommand config_command_;
  bool has_config_command_;
  ::bes::failure_details::ConfigurableQuery configurable_query_;
  bool has_configurable_query_;
  ::bes::failure_details::DumpCommand dump_command_;
  bool has_dump_command_;
  ::bes::failure_details::HelpCommand help_command_;
  bool has_help_command_;
  ::bes::failure_details::MobileInstall mobile_install_;
  bool has_mobile_install_;
  ::bes::failure_details::ProfileCommand profile_command_;
  bool has_profile_command_;
  ::bes::failure_details::RunCommand run_command_;
  bool has_run_command_;
  ::bes::failure_details::VersionCommand version_command_;
  bool has_version_command_;
  ::bes::failure_details::PrintActionCommand print_action_command_;
  bool has_print_action_command_;
  ::bes::failure_details::WorkspaceStatus workspace_status_;
  bool has_workspace_status_;
  ::bes::failure_details::JavaCompile java_compile_;
  bool has_java_compile_;
  ::bes::failure_details::ActionRewinding action_rewinding_;
  bool has_action_rewinding_;
  ::bes::failure_details::CppCompile cpp_compile_;
  bool has_cpp_compile_;
  ::bes::failure_details::StarlarkAction starlark_action_;
  bool has_starlark_action_;
  ::bes::failure_details::NinjaAction ninja_action_;
  bool has_ninja_action_;
  ::bes::failure_details::DynamicExecution dynamic_execution_;
  bool has_dynamic_execution_;
  ::bes::failure_details::FailAction fail_action_;
  bool has_fail_action_;
  ::bes::failure_details::SymlinkAction symlink_action_;
  bool has_symlink_action_;
  ::bes::failure_details::CppLink cpp_link_;
  bool has_cpp_link_;
  ::bes::failure_details::LtoAction lto_action_;
  bool has_lto_action_;
  ::bes::failure_details::TestAction test_action_;
  bool has_test_action_;
  ::bes::failure_details::Worker worker_;
  bool has_worker_;
  ::bes::failure_details::Analysis analysis_;
  bool has_analysis_;
  ::bes::failure_details::PackageLoading package_loading_;
  bool has_package_loading_;
  ::bes::failure_details::Toolchain toolchain_;
  bool has_toolchain_;
  ::bes::failure_details::StarlarkLoading starlark_loading_;
  bool has_starlark_loading_;
  ::bes::failure_details::ExternalDeps external_deps_;
  bool has_external_deps_;
  ::bes::failure_details::DiffAwareness diff_awareness_;
  bool has_diff_awareness_;
  ::bes::failure_details::ModCommand mod_command_;
  bool has_mod_command_;
  ::bes::failure_details::BuildReport build_report_;
  bool has_build_report_;
  ::bes::failure_details::Skyfocus skyfocus_;
  bool has_skyfocus_;
  ::bes::failure_details::RemoteAnalysisCaching remote_analysis_caching_;
  bool has_remote_analysis_caching_;

  FailureDetail();
  FailureDetail(const FailureDetail&) = default;
  FailureDetail(FailureDetail&&) = default;
  FailureDetail& operator=(const FailureDetail&) = default;
  FailureDetail& operator=(FailureDetail&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_message() {
    has_message_ = true;
    return &message_;
  }
  void set_message(const std::string& value);
  ::bes::failure_details::Interrupted* mutable_interrupted() {
    has_interrupted_ = true;
    return &interrupted_;
  }
  ::bes::failure_details::ExternalRepository* mutable_external_repository() {
    has_external_repository_ = true;
    return &external_repository_;
  }
  ::bes::failure_details::BuildProgress* mutable_build_progress() {
    has_build_progress_ = true;
    return &build_progress_;
  }
  ::bes::failure_details::RemoteOptions* mutable_remote_options() {
    has_remote_options_ = true;
    return &remote_options_;
  }
  ::bes::failure_details::ClientEnvironment* mutable_client_environment() {
    has_client_environment_ = true;
    return &client_environment_;
  }
  ::bes::failure_details::Crash* mutable_crash() {
    has_crash_ = true;
    return &crash_;
  }
  ::bes::failure_details::SymlinkForest* mutable_symlink_forest() {
    has_symlink_forest_ = true;
    return &symlink_forest_;
  }
  ::bes::failure_details::PackageOptions* mutable_package_options() {
    has_package_options_ = true;
    return &package_options_;
  }
  ::bes::failure_details::RemoteExecution* mutable_remote_execution() {
    has_remote_execution_ = true;
    return &remote_execution_;
  }
  ::bes::failure_details::Execution* mutable_execution() {
    has_execution_ = true;
    return &execution_;
  }
  ::bes::failure_details::Workspaces* mutable_workspaces() {
    has_workspaces_ = true;
    return &workspaces_;
  }
  ::bes::failure_details::CrashOptions* mutable_crash_options() {
    has_crash_options_ = true;
    return &crash_options_;
  }
  ::bes::failure_details::Filesystem* mutable_filesystem() {
    has_filesystem_ = true;
    return &filesystem_;
  }
  ::bes::failure_details::ExecutionOptions* mutable_execution_options() {
    has_execution_options_ = true;
    return &execution_options_;
  }
  ::bes::failure_details::Command* mutable_command() {
    has_command_ = true;
    return &command_;
  }
  ::bes::failure_details::Spawn* mutable_spawn() {
    has_spawn_ = true;
    return &spawn_;
  }
  ::bes::failure_details::GrpcServer* mutable_grpc_server() {
    has_grpc_server_ = true;
    return &grpc_server_;
  }
  ::bes::failure_details::CanonicalizeFlags* mutable_canonicalize_flags() {
    has_canonicalize_flags_ = true;
    return &canonicalize_flags_;
  }
  ::bes::failure_details::BuildConfiguration* mutable_build_configuration() {
    has_build_configuration_ = true;
    return &build_configuration_;
  }
  ::bes::failure_details::InfoCommand* mutable_info_command() {
    has_info_command_ = true;
    return &info_command_;
  }
  ::bes::failure_details::MemoryOptions* mutable_memory_options() {
    has_memory_options_ = true;
    return &memory_options_;
  }
  ::bes::failure_details::Query* mutable_query() {
    has_query_ = true;
    return &query_;
  }
  ::bes::failure_details::LocalExecution* mutable_local_execution() {
    has_local_execution_ = true;
    return &local_execution_;
  }
  ::bes::failure_details::ActionCache* mutable_action_cache() {
    has_action_cache_ = true;
    return &action_cache_;
  }
  ::bes::failure_details::FetchCommand* mutable_fetch_command() {
    has_fetch_command_ = true;
    return &fetch_command_;
  }
  ::bes::failure_details::SyncCommand* mutable_sync_command() {
    has_sync_command_ = true;
    return &sync_command_;
  }
  ::bes::failure_details::Sandbox* mutable_sandbox() {
    has_sandbox_ = true;
    return &sandbox_;
  }
  ::bes::failure_details::IncludeScanning* mutable_include_scanning() {
    has_include_scanning_ = true;
    return &include_scanning_;
  }
  ::bes::failure_details::TestCommand* mutable_test_command() {
    has_test_command_ = true;
    return &test_command_;
  }
  ::bes::failure_details::ActionQuery* mutable_action_query() {
    has_action_query_ = true;
    return &action_query_;
  }
  ::bes::failure_details::TargetPatterns* mutable_target_patterns() {
    has_target_patterns_ = true;
    return &target_patterns_;
  }
  ::bes::failure_details::CleanCommand* mutable_clean_command() {
    has_clean_command_ = true;
    return &clean_command_;
  }
  ::bes::failure_details::ConfigCommand* mutable_config_command() {
    has_config_command_ = true;
    return &config_command_;
  }
  ::bes::failure_details::ConfigurableQuery* mutable_configurable_query() {
    has_configurable_query_ = true;
    return &configurable_query_;
  }
  ::bes::failure_details::DumpCommand* mutable_dump_command() {
    has_dump_command_ = true;
    return &dump_command_;
  }
  ::bes::failure_details::HelpCommand* mutable_help_command() {
    has_help_command_ = true;
    return &help_command_;
  }
  ::bes::failure_details::MobileInstall* mutable_mobile_install() {
    has_mobile_install_ = true;
    return &mobile_install_;
  }
  ::bes::failure_details::ProfileCommand* mutable_profile_command() {
    has_profile_command_ = true;
    return &profile_command_;
  }
  ::bes::failure_details::RunCommand* mutable_run_command() {
    has_run_command_ = true;
    return &run_command_;
  }
  ::bes::failure_details::VersionCommand* mutable_version_command() {
    has_version_command_ = true;
    return &version_command_;
  }
  ::bes::failure_details::PrintActionCommand* mutable_print_action_command() {
    has_print_action_command_ = true;
    return &print_action_command_;
  }
  ::bes::failure_details::WorkspaceStatus* mutable_workspace_status() {
    has_workspace_status_ = true;
    return &workspace_status_;
  }
  ::bes::failure_details::JavaCompile* mutable_java_compile() {
    has_java_compile_ = true;
    return &java_compile_;
  }
  ::bes::failure_details::ActionRewinding* mutable_action_rewinding() {
    has_action_rewinding_ = true;
    return &action_rewinding_;
  }
  ::bes::failure_details::CppCompile* mutable_cpp_compile() {
    has_cpp_compile_ = true;
    return &cpp_compile_;
  }
  ::bes::failure_details::StarlarkAction* mutable_starlark_action() {
    has_starlark_action_ = true;
    return &starlark_action_;
  }
  ::bes::failure_details::NinjaAction* mutable_ninja_action() {
    has_ninja_action_ = true;
    return &ninja_action_;
  }
  ::bes::failure_details::DynamicExecution* mutable_dynamic_execution() {
    has_dynamic_execution_ = true;
    return &dynamic_execution_;
  }
  ::bes::failure_details::FailAction* mutable_fail_action() {
    has_fail_action_ = true;
    return &fail_action_;
  }
  ::bes::failure_details::SymlinkAction* mutable_symlink_action() {
    has_symlink_action_ = true;
    return &symlink_action_;
  }
  ::bes::failure_details::CppLink* mutable_cpp_link() {
    has_cpp_link_ = true;
    return &cpp_link_;
  }
  ::bes::failure_details::LtoAction* mutable_lto_action() {
    has_lto_action_ = true;
    return &lto_action_;
  }
  ::bes::failure_details::TestAction* mutable_test_action() {
    has_test_action_ = true;
    return &test_action_;
  }
  ::bes::failure_details::Worker* mutable_worker() {
    has_worker_ = true;
    return &worker_;
  }
  ::bes::failure_details::Analysis* mutable_analysis() {
    has_analysis_ = true;
    return &analysis_;
  }
  ::bes::failure_details::PackageLoading* mutable_package_loading() {
    has_package_loading_ = true;
    return &package_loading_;
  }
  ::bes::failure_details::Toolchain* mutable_toolchain() {
    has_toolchain_ = true;
    return &toolchain_;
  }
  ::bes::failure_details::StarlarkLoading* mutable_starlark_loading() {
    has_starlark_loading_ = true;
    return &starlark_loading_;
  }
  ::bes::failure_details::ExternalDeps* mutable_external_deps() {
    has_external_deps_ = true;
    return &external_deps_;
  }
  ::bes::failure_details::DiffAwareness* mutable_diff_awareness() {
    has_diff_awareness_ = true;
    return &diff_awareness_;
  }
  ::bes::failure_details::ModCommand* mutable_mod_command() {
    has_mod_command_ = true;
    return &mod_command_;
  }
  ::bes::failure_details::BuildReport* mutable_build_report() {
    has_build_report_ = true;
    return &build_report_;
  }
  ::bes::failure_details::Skyfocus* mutable_skyfocus() {
    has_skyfocus_ = true;
    return &skyfocus_;
  }
  ::bes::failure_details::RemoteAnalysisCaching* mutable_remote_analysis_caching() {
    has_remote_analysis_caching_ = true;
    return &remote_analysis_caching_;
  }
};  // struct FailureDetail
struct Throwable {
  std::string throwable_class_;
  bool has_throwable_class_;
  std::string message_;
  bool has_message_;
  std::vector< std::string > stack_trace_;
  bool has_stack_trace_;

  Throwable();
  Throwable(const Throwable&) = default;
  Throwable(Throwable&&) = default;
  Throwable& operator=(const Throwable&) = default;
  Throwable& operator=(Throwable&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_throwable_class() {
    has_throwable_class_ = true;
    return &throwable_class_;
  }
  void set_throwable_class(const std::string& value);
  std::string* mutable_message() {
    has_message_ = true;
    return &message_;
  }
  void set_message(const std::string& value);
  std::vector< std::string >* mutable_stack_trace() {
    has_stack_trace_ = true;
    return &stack_trace_;
  }
  void add_stack_trace(const std::string& value);
  void set_stack_trace(const std::vector< std::string >& value);
};  // struct Throwable
}  // namespace failure_details
namespace blaze {
namespace strategy_policy {
struct MnemonicPolicy {
  std::vector< std::string > default_allowlist_;
  bool has_default_allowlist_;
  std::vector< ::bes::blaze::strategy_policy::StrategiesForMnemonic > strategy_allowlist_;
  bool has_strategy_allowlist_;

  MnemonicPolicy();
  MnemonicPolicy(const MnemonicPolicy&) = default;
  MnemonicPolicy(MnemonicPolicy&&) = default;
  MnemonicPolicy& operator=(const MnemonicPolicy&) = default;
  MnemonicPolicy& operator=(MnemonicPolicy&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< std::string >* mutable_default_allowlist() {
    has_default_allowlist_ = true;
    return &default_allowlist_;
  }
  void add_default_allowlist(const std::string& value);
  void set_default_allowlist(const std::vector< std::string >& value);
  std::vector< ::bes::blaze::strategy_policy::StrategiesForMnemonic >* mutable_strategy_allowlist() {
    has_strategy_allowlist_ = true;
    return &strategy_allowlist_;
  }
  void add_strategy_allowlist(const ::bes::blaze::strategy_policy::StrategiesForMnemonic& value);
};  // struct MnemonicPolicy
struct StrategyPolicy {
  ::bes::blaze::strategy_policy::MnemonicPolicy mnemonic_policy_;
  bool has_mnemonic_policy_;
  ::bes::blaze::strategy_policy::MnemonicPolicy dynamic_remote_policy_;
  bool has_dynamic_remote_policy_;
  ::bes::blaze::strategy_policy::MnemonicPolicy dynamic_local_policy_;
  bool has_dynamic_local_policy_;

  StrategyPolicy();
  StrategyPolicy(const StrategyPolicy&) = default;
  StrategyPolicy(StrategyPolicy&&) = default;
  StrategyPolicy& operator=(const StrategyPolicy&) = default;
  StrategyPolicy& operator=(StrategyPolicy&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::blaze::strategy_policy::MnemonicPolicy* mutable_mnemonic_policy() {
    has_mnemonic_policy_ = true;
    return &mnemonic_policy_;
  }
  ::bes::blaze::strategy_policy::MnemonicPolicy* mutable_dynamic_remote_policy() {
    has_dynamic_remote_policy_ = true;
    return &dynamic_remote_policy_;
  }
  ::bes::blaze::strategy_policy::MnemonicPolicy* mutable_dynamic_local_policy() {
    has_dynamic_local_policy_ = true;
    return &dynamic_local_policy_;
  }
};  // struct StrategyPolicy
struct StrategiesForMnemonic {
  std::string mnemonic_;
  bool has_mnemonic_;
  std::vector< std::string > strategy_;
  bool has_strategy_;

  StrategiesForMnemonic();
  StrategiesForMnemonic(const StrategiesForMnemonic&) = default;
  StrategiesForMnemonic(StrategiesForMnemonic&&) = default;
  StrategiesForMnemonic& operator=(const StrategiesForMnemonic&) = default;
  StrategiesForMnemonic& operator=(StrategiesForMnemonic&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_mnemonic() {
    has_mnemonic_ = true;
    return &mnemonic_;
  }
  void set_mnemonic(const std::string& value);
  std::vector< std::string >* mutable_strategy() {
    has_strategy_ = true;
    return &strategy_;
  }
  void add_strategy(const std::string& value);
  void set_strategy(const std::vector< std::string >& value);
};  // struct StrategiesForMnemonic
}  // namespace strategy_policy
}  // namespace blaze
namespace blaze {
namespace invocation_policy {
struct InvocationPolicy {
  std::vector< ::bes::blaze::invocation_policy::FlagPolicy > flag_policies_;
  bool has_flag_policies_;
  ::bes::blaze::strategy_policy::StrategyPolicy strategy_policy_;
  bool has_strategy_policy_;

  InvocationPolicy();
  InvocationPolicy(const InvocationPolicy&) = default;
  InvocationPolicy(InvocationPolicy&&) = default;
  InvocationPolicy& operator=(const InvocationPolicy&) = default;
  InvocationPolicy& operator=(InvocationPolicy&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::blaze::invocation_policy::FlagPolicy >* mutable_flag_policies() {
    has_flag_policies_ = true;
    return &flag_policies_;
  }
  void add_flag_policies(const ::bes::blaze::invocation_policy::FlagPolicy& value);
  ::bes::blaze::strategy_policy::StrategyPolicy* mutable_strategy_policy() {
    has_strategy_policy_ = true;
    return &strategy_policy_;
  }
};  // struct InvocationPolicy
struct UseDefault {
  UseDefault();
  UseDefault(const UseDefault&) = default;
  UseDefault(UseDefault&&) = default;
  UseDefault& operator=(const UseDefault&) = default;
  UseDefault& operator=(UseDefault&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
};  // struct UseDefault
struct AllowValues {
  std::vector< std::string > allowed_values_;
  bool has_allowed_values_;
  std::string new_value_;
  bool has_new_value_;
  ::bes::blaze::invocation_policy::UseDefault use_default_;
  bool has_use_default_;

  AllowValues();
  AllowValues(const AllowValues&) = default;
  AllowValues(AllowValues&&) = default;
  AllowValues& operator=(const AllowValues&) = default;
  AllowValues& operator=(AllowValues&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< std::string >* mutable_allowed_values() {
    has_allowed_values_ = true;
    return &allowed_values_;
  }
  void add_allowed_values(const std::string& value);
  void set_allowed_values(const std::vector< std::string >& value);
  std::string* mutable_new_value() {
    has_new_value_ = true;
    return &new_value_;
  }
  void set_new_value(const std::string& value);
  ::bes::blaze::invocation_policy::UseDefault* mutable_use_default() {
    has_use_default_ = true;
    return &use_default_;
  }
};  // struct AllowValues
struct DisallowValues {
  std::vector< std::string > disallowed_values_;
  bool has_disallowed_values_;
  std::string new_value_;
  bool has_new_value_;
  ::bes::blaze::invocation_policy::UseDefault use_default_;
  bool has_use_default_;

  DisallowValues();
  DisallowValues(const DisallowValues&) = default;
  DisallowValues(DisallowValues&&) = default;
  DisallowValues& operator=(const DisallowValues&) = default;
  DisallowValues& operator=(DisallowValues&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< std::string >* mutable_disallowed_values() {
    has_disallowed_values_ = true;
    return &disallowed_values_;
  }
  void add_disallowed_values(const std::string& value);
  void set_disallowed_values(const std::vector< std::string >& value);
  std::string* mutable_new_value() {
    has_new_value_ = true;
    return &new_value_;
  }
  void set_new_value(const std::string& value);
  ::bes::blaze::invocation_policy::UseDefault* mutable_use_default() {
    has_use_default_ = true;
    return &use_default_;
  }
};  // struct DisallowValues
struct SetValue {
  enum Behavior {
    UNDEFINED = 0,
    ALLOW_OVERRIDES = 1,
    APPEND = 2,
    FINAL_VALUE_IGNORE_OVERRIDES = 3,
  };

  std::vector< std::string > flag_value_;
  bool has_flag_value_;
  ::bes::blaze::invocation_policy::SetValue::Behavior behavior_;
  bool has_behavior_;

  SetValue();
  SetValue(const SetValue&) = default;
  SetValue(SetValue&&) = default;
  SetValue& operator=(const SetValue&) = default;
  SetValue& operator=(SetValue&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< std::string >* mutable_flag_value() {
    has_flag_value_ = true;
    return &flag_value_;
  }
  void add_flag_value(const std::string& value);
  void set_flag_value(const std::vector< std::string >& value);
  ::bes::blaze::invocation_policy::SetValue::Behavior* mutable_behavior() {
    has_behavior_ = true;
    return &behavior_;
  }
  void set_behavior(const ::bes::blaze::invocation_policy::SetValue::Behavior& value);
};  // struct SetValue
struct FlagPolicy {
  std::string flag_name_;
  bool has_flag_name_;
  std::vector< std::string > commands_;
  bool has_commands_;
  ::bes::blaze::invocation_policy::SetValue set_value_;
  bool has_set_value_;
  ::bes::blaze::invocation_policy::UseDefault use_default_;
  bool has_use_default_;
  ::bes::blaze::invocation_policy::DisallowValues disallow_values_;
  bool has_disallow_values_;
  ::bes::blaze::invocation_policy::AllowValues allow_values_;
  bool has_allow_values_;

  FlagPolicy();
  FlagPolicy(const FlagPolicy&) = default;
  FlagPolicy(FlagPolicy&&) = default;
  FlagPolicy& operator=(const FlagPolicy&) = default;
  FlagPolicy& operator=(FlagPolicy&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_flag_name() {
    has_flag_name_ = true;
    return &flag_name_;
  }
  void set_flag_name(const std::string& value);
  std::vector< std::string >* mutable_commands() {
    has_commands_ = true;
    return &commands_;
  }
  void add_commands(const std::string& value);
  void set_commands(const std::vector< std::string >& value);
  ::bes::blaze::invocation_policy::SetValue* mutable_set_value() {
    has_set_value_ = true;
    return &set_value_;
  }
  ::bes::blaze::invocation_policy::UseDefault* mutable_use_default() {
    has_use_default_ = true;
    return &use_default_;
  }
  ::bes::blaze::invocation_policy::DisallowValues* mutable_disallow_values() {
    has_disallow_values_ = true;
    return &disallow_values_;
  }
  ::bes::blaze::invocation_policy::AllowValues* mutable_allow_values() {
    has_allow_values_ = true;
    return &allow_values_;
  }
};  // struct FlagPolicy
}  // namespace invocation_policy
}  // namespace blaze
namespace build_event_stream {
enum TestSize {
  UNKNOWN = 0,
  SMALL = 1,
  MEDIUM = 2,
  LARGE = 3,
  ENORMOUS = 4,
};

enum TestStatus {
  NO_STATUS = 0,
  PASSED = 1,
  FLAKY = 2,
  TIMEOUT = 3,
  FAILED = 4,
  INCOMPLETE = 5,
  REMOTE_FAILURE = 6,
  FAILED_TO_BUILD = 7,
  TOOL_HALTED_BEFORE_TESTING = 8,
};

struct BuildEventId {
  struct UnknownBuildEventId {
    std::string details_;
    bool has_details_;

    UnknownBuildEventId();
    UnknownBuildEventId(const UnknownBuildEventId&) = default;
    UnknownBuildEventId(UnknownBuildEventId&&) = default;
    UnknownBuildEventId& operator=(const UnknownBuildEventId&) = default;
    UnknownBuildEventId& operator=(UnknownBuildEventId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_details() {
      has_details_ = true;
      return &details_;
    }
    void set_details(const std::string& value);
  };  // struct UnknownBuildEventId
  struct ProgressId {
    int32_t opaque_count_;
    bool has_opaque_count_;

    ProgressId();
    ProgressId(const ProgressId&) = default;
    ProgressId(ProgressId&&) = default;
    ProgressId& operator=(const ProgressId&) = default;
    ProgressId& operator=(ProgressId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int32_t* mutable_opaque_count() {
      has_opaque_count_ = true;
      return &opaque_count_;
    }
    void set_opaque_count(const int32_t& value);
  };  // struct ProgressId
  struct BuildStartedId {
    BuildStartedId();
    BuildStartedId(const BuildStartedId&) = default;
    BuildStartedId(BuildStartedId&&) = default;
    BuildStartedId& operator=(const BuildStartedId&) = default;
    BuildStartedId& operator=(BuildStartedId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct BuildStartedId
  struct UnstructuredCommandLineId {
    UnstructuredCommandLineId();
    UnstructuredCommandLineId(const UnstructuredCommandLineId&) = default;
    UnstructuredCommandLineId(UnstructuredCommandLineId&&) = default;
    UnstructuredCommandLineId& operator=(const UnstructuredCommandLineId&) = default;
    UnstructuredCommandLineId& operator=(UnstructuredCommandLineId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct UnstructuredCommandLineId
  struct StructuredCommandLineId {
    std::string command_line_label_;
    bool has_command_line_label_;

    StructuredCommandLineId();
    StructuredCommandLineId(const StructuredCommandLineId&) = default;
    StructuredCommandLineId(StructuredCommandLineId&&) = default;
    StructuredCommandLineId& operator=(const StructuredCommandLineId&) = default;
    StructuredCommandLineId& operator=(StructuredCommandLineId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_command_line_label() {
      has_command_line_label_ = true;
      return &command_line_label_;
    }
    void set_command_line_label(const std::string& value);
  };  // struct StructuredCommandLineId
  struct WorkspaceStatusId {
    WorkspaceStatusId();
    WorkspaceStatusId(const WorkspaceStatusId&) = default;
    WorkspaceStatusId(WorkspaceStatusId&&) = default;
    WorkspaceStatusId& operator=(const WorkspaceStatusId&) = default;
    WorkspaceStatusId& operator=(WorkspaceStatusId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct WorkspaceStatusId
  struct OptionsParsedId {
    OptionsParsedId();
    OptionsParsedId(const OptionsParsedId&) = default;
    OptionsParsedId(OptionsParsedId&&) = default;
    OptionsParsedId& operator=(const OptionsParsedId&) = default;
    OptionsParsedId& operator=(OptionsParsedId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct OptionsParsedId
  struct FetchId {
    std::string url_;
    bool has_url_;

    FetchId();
    FetchId(const FetchId&) = default;
    FetchId(FetchId&&) = default;
    FetchId& operator=(const FetchId&) = default;
    FetchId& operator=(FetchId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_url() {
      has_url_ = true;
      return &url_;
    }
    void set_url(const std::string& value);
  };  // struct FetchId
  struct PatternExpandedId {
    std::vector< std::string > pattern_;
    bool has_pattern_;

    PatternExpandedId();
    PatternExpandedId(const PatternExpandedId&) = default;
    PatternExpandedId(PatternExpandedId&&) = default;
    PatternExpandedId& operator=(const PatternExpandedId&) = default;
    PatternExpandedId& operator=(PatternExpandedId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    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);
  };  // struct PatternExpandedId
  struct WorkspaceConfigId {
    WorkspaceConfigId();
    WorkspaceConfigId(const WorkspaceConfigId&) = default;
    WorkspaceConfigId(WorkspaceConfigId&&) = default;
    WorkspaceConfigId& operator=(const WorkspaceConfigId&) = default;
    WorkspaceConfigId& operator=(WorkspaceConfigId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct WorkspaceConfigId
  struct BuildMetadataId {
    BuildMetadataId();
    BuildMetadataId(const BuildMetadataId&) = default;
    BuildMetadataId(BuildMetadataId&&) = default;
    BuildMetadataId& operator=(const BuildMetadataId&) = default;
    BuildMetadataId& operator=(BuildMetadataId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct BuildMetadataId
  struct TargetConfiguredId {
    std::string label_;
    bool has_label_;
    std::string aspect_;
    bool has_aspect_;

    TargetConfiguredId();
    TargetConfiguredId(const TargetConfiguredId&) = default;
    TargetConfiguredId(TargetConfiguredId&&) = default;
    TargetConfiguredId& operator=(const TargetConfiguredId&) = default;
    TargetConfiguredId& operator=(TargetConfiguredId&&) = default;
    void SerializeToOstream(std::ostream* 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_aspect() {
      has_aspect_ = true;
      return &aspect_;
    }
    void set_aspect(const std::string& value);
  };  // struct TargetConfiguredId
  struct NamedSetOfFilesId {
    std::string id_;
    bool has_id_;

    NamedSetOfFilesId();
    NamedSetOfFilesId(const NamedSetOfFilesId&) = default;
    NamedSetOfFilesId(NamedSetOfFilesId&&) = default;
    NamedSetOfFilesId& operator=(const NamedSetOfFilesId&) = default;
    NamedSetOfFilesId& operator=(NamedSetOfFilesId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_id() {
      has_id_ = true;
      return &id_;
    }
    void set_id(const std::string& value);
  };  // struct NamedSetOfFilesId
  struct ConfigurationId {
    std::string id_;
    bool has_id_;

    ConfigurationId();
    ConfigurationId(const ConfigurationId&) = default;
    ConfigurationId(ConfigurationId&&) = default;
    ConfigurationId& operator=(const ConfigurationId&) = default;
    ConfigurationId& operator=(ConfigurationId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_id() {
      has_id_ = true;
      return &id_;
    }
    void set_id(const std::string& value);
  };  // struct ConfigurationId
  struct TargetCompletedId {
    std::string label_;
    bool has_label_;
    ::bes::build_event_stream::BuildEventId::ConfigurationId configuration_;
    bool has_configuration_;
    std::string aspect_;
    bool has_aspect_;

    TargetCompletedId();
    TargetCompletedId(const TargetCompletedId&) = default;
    TargetCompletedId(TargetCompletedId&&) = default;
    TargetCompletedId& operator=(const TargetCompletedId&) = default;
    TargetCompletedId& operator=(TargetCompletedId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_label() {
      has_label_ = true;
      return &label_;
    }
    void set_label(const std::string& value);
    ::bes::build_event_stream::BuildEventId::ConfigurationId* mutable_configuration() {
      has_configuration_ = true;
      return &configuration_;
    }
    std::string* mutable_aspect() {
      has_aspect_ = true;
      return &aspect_;
    }
    void set_aspect(const std::string& value);
  };  // struct TargetCompletedId
  struct ActionCompletedId {
    std::string primary_output_;
    bool has_primary_output_;
    std::string label_;
    bool has_label_;
    ::bes::build_event_stream::BuildEventId::ConfigurationId configuration_;
    bool has_configuration_;

    ActionCompletedId();
    ActionCompletedId(const ActionCompletedId&) = default;
    ActionCompletedId(ActionCompletedId&&) = default;
    ActionCompletedId& operator=(const ActionCompletedId&) = default;
    ActionCompletedId& operator=(ActionCompletedId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_primary_output() {
      has_primary_output_ = true;
      return &primary_output_;
    }
    void set_primary_output(const std::string& value);
    std::string* mutable_label() {
      has_label_ = true;
      return &label_;
    }
    void set_label(const std::string& value);
    ::bes::build_event_stream::BuildEventId::ConfigurationId* mutable_configuration() {
      has_configuration_ = true;
      return &configuration_;
    }
  };  // struct ActionCompletedId
  struct UnconfiguredLabelId {
    std::string label_;
    bool has_label_;

    UnconfiguredLabelId();
    UnconfiguredLabelId(const UnconfiguredLabelId&) = default;
    UnconfiguredLabelId(UnconfiguredLabelId&&) = default;
    UnconfiguredLabelId& operator=(const UnconfiguredLabelId&) = default;
    UnconfiguredLabelId& operator=(UnconfiguredLabelId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_label() {
      has_label_ = true;
      return &label_;
    }
    void set_label(const std::string& value);
  };  // struct UnconfiguredLabelId
  struct ConfiguredLabelId {
    std::string label_;
    bool has_label_;
    ::bes::build_event_stream::BuildEventId::ConfigurationId configuration_;
    bool has_configuration_;

    ConfiguredLabelId();
    ConfiguredLabelId(const ConfiguredLabelId&) = default;
    ConfiguredLabelId(ConfiguredLabelId&&) = default;
    ConfiguredLabelId& operator=(const ConfiguredLabelId&) = default;
    ConfiguredLabelId& operator=(ConfiguredLabelId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_label() {
      has_label_ = true;
      return &label_;
    }
    void set_label(const std::string& value);
    ::bes::build_event_stream::BuildEventId::ConfigurationId* mutable_configuration() {
      has_configuration_ = true;
      return &configuration_;
    }
  };  // struct ConfiguredLabelId
  struct TestResultId {
    std::string label_;
    bool has_label_;
    ::bes::build_event_stream::BuildEventId::ConfigurationId configuration_;
    bool has_configuration_;
    int32_t run_;
    bool has_run_;
    int32_t shard_;
    bool has_shard_;
    int32_t attempt_;
    bool has_attempt_;

    TestResultId();
    TestResultId(const TestResultId&) = default;
    TestResultId(TestResultId&&) = default;
    TestResultId& operator=(const TestResultId&) = default;
    TestResultId& operator=(TestResultId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_label() {
      has_label_ = true;
      return &label_;
    }
    void set_label(const std::string& value);
    ::bes::build_event_stream::BuildEventId::ConfigurationId* mutable_configuration() {
      has_configuration_ = true;
      return &configuration_;
    }
    int32_t* mutable_run() {
      has_run_ = true;
      return &run_;
    }
    void set_run(const int32_t& value);
    int32_t* mutable_shard() {
      has_shard_ = true;
      return &shard_;
    }
    void set_shard(const int32_t& value);
    int32_t* mutable_attempt() {
      has_attempt_ = true;
      return &attempt_;
    }
    void set_attempt(const int32_t& value);
  };  // struct TestResultId
  struct TestProgressId {
    std::string label_;
    bool has_label_;
    ::bes::build_event_stream::BuildEventId::ConfigurationId configuration_;
    bool has_configuration_;
    int32_t run_;
    bool has_run_;
    int32_t shard_;
    bool has_shard_;
    int32_t attempt_;
    bool has_attempt_;
    int32_t opaque_count_;
    bool has_opaque_count_;

    TestProgressId();
    TestProgressId(const TestProgressId&) = default;
    TestProgressId(TestProgressId&&) = default;
    TestProgressId& operator=(const TestProgressId&) = default;
    TestProgressId& operator=(TestProgressId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_label() {
      has_label_ = true;
      return &label_;
    }
    void set_label(const std::string& value);
    ::bes::build_event_stream::BuildEventId::ConfigurationId* mutable_configuration() {
      has_configuration_ = true;
      return &configuration_;
    }
    int32_t* mutable_run() {
      has_run_ = true;
      return &run_;
    }
    void set_run(const int32_t& value);
    int32_t* mutable_shard() {
      has_shard_ = true;
      return &shard_;
    }
    void set_shard(const int32_t& value);
    int32_t* mutable_attempt() {
      has_attempt_ = true;
      return &attempt_;
    }
    void set_attempt(const int32_t& value);
    int32_t* mutable_opaque_count() {
      has_opaque_count_ = true;
      return &opaque_count_;
    }
    void set_opaque_count(const int32_t& value);
  };  // struct TestProgressId
  struct TestSummaryId {
    std::string label_;
    bool has_label_;
    ::bes::build_event_stream::BuildEventId::ConfigurationId configuration_;
    bool has_configuration_;

    TestSummaryId();
    TestSummaryId(const TestSummaryId&) = default;
    TestSummaryId(TestSummaryId&&) = default;
    TestSummaryId& operator=(const TestSummaryId&) = default;
    TestSummaryId& operator=(TestSummaryId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_label() {
      has_label_ = true;
      return &label_;
    }
    void set_label(const std::string& value);
    ::bes::build_event_stream::BuildEventId::ConfigurationId* mutable_configuration() {
      has_configuration_ = true;
      return &configuration_;
    }
  };  // struct TestSummaryId
  struct TargetSummaryId {
    std::string label_;
    bool has_label_;
    ::bes::build_event_stream::BuildEventId::ConfigurationId configuration_;
    bool has_configuration_;

    TargetSummaryId();
    TargetSummaryId(const TargetSummaryId&) = default;
    TargetSummaryId(TargetSummaryId&&) = default;
    TargetSummaryId& operator=(const TargetSummaryId&) = default;
    TargetSummaryId& operator=(TargetSummaryId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_label() {
      has_label_ = true;
      return &label_;
    }
    void set_label(const std::string& value);
    ::bes::build_event_stream::BuildEventId::ConfigurationId* mutable_configuration() {
      has_configuration_ = true;
      return &configuration_;
    }
  };  // struct TargetSummaryId
  struct BuildFinishedId {
    BuildFinishedId();
    BuildFinishedId(const BuildFinishedId&) = default;
    BuildFinishedId(BuildFinishedId&&) = default;
    BuildFinishedId& operator=(const BuildFinishedId&) = default;
    BuildFinishedId& operator=(BuildFinishedId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct BuildFinishedId
  struct BuildToolLogsId {
    BuildToolLogsId();
    BuildToolLogsId(const BuildToolLogsId&) = default;
    BuildToolLogsId(BuildToolLogsId&&) = default;
    BuildToolLogsId& operator=(const BuildToolLogsId&) = default;
    BuildToolLogsId& operator=(BuildToolLogsId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct BuildToolLogsId
  struct BuildMetricsId {
    BuildMetricsId();
    BuildMetricsId(const BuildMetricsId&) = default;
    BuildMetricsId(BuildMetricsId&&) = default;
    BuildMetricsId& operator=(const BuildMetricsId&) = default;
    BuildMetricsId& operator=(BuildMetricsId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct BuildMetricsId
  struct ConvenienceSymlinksIdentifiedId {
    ConvenienceSymlinksIdentifiedId();
    ConvenienceSymlinksIdentifiedId(const ConvenienceSymlinksIdentifiedId&) = default;
    ConvenienceSymlinksIdentifiedId(ConvenienceSymlinksIdentifiedId&&) = default;
    ConvenienceSymlinksIdentifiedId& operator=(const ConvenienceSymlinksIdentifiedId&) = default;
    ConvenienceSymlinksIdentifiedId& operator=(ConvenienceSymlinksIdentifiedId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct ConvenienceSymlinksIdentifiedId
  struct ExecRequestId {
    ExecRequestId();
    ExecRequestId(const ExecRequestId&) = default;
    ExecRequestId(ExecRequestId&&) = default;
    ExecRequestId& operator=(const ExecRequestId&) = default;
    ExecRequestId& operator=(ExecRequestId&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
  };  // struct ExecRequestId
  ::bes::build_event_stream::BuildEventId::UnknownBuildEventId unknown_;
  bool has_unknown_;
  ::bes::build_event_stream::BuildEventId::ProgressId progress_;
  bool has_progress_;
  ::bes::build_event_stream::BuildEventId::BuildStartedId started_;
  bool has_started_;
  ::bes::build_event_stream::BuildEventId::UnstructuredCommandLineId unstructured_command_line_;
  bool has_unstructured_command_line_;
  ::bes::build_event_stream::BuildEventId::StructuredCommandLineId structured_command_line_;
  bool has_structured_command_line_;
  ::bes::build_event_stream::BuildEventId::WorkspaceStatusId workspace_status_;
  bool has_workspace_status_;
  ::bes::build_event_stream::BuildEventId::OptionsParsedId options_parsed_;
  bool has_options_parsed_;
  ::bes::build_event_stream::BuildEventId::FetchId fetch_;
  bool has_fetch_;
  ::bes::build_event_stream::BuildEventId::ConfigurationId configuration_;
  bool has_configuration_;
  ::bes::build_event_stream::BuildEventId::TargetConfiguredId target_configured_;
  bool has_target_configured_;
  ::bes::build_event_stream::BuildEventId::PatternExpandedId pattern_;
  bool has_pattern_;
  ::bes::build_event_stream::BuildEventId::PatternExpandedId pattern_skipped_;
  bool has_pattern_skipped_;
  ::bes::build_event_stream::BuildEventId::NamedSetOfFilesId named_set_;
  bool has_named_set_;
  ::bes::build_event_stream::BuildEventId::TargetCompletedId target_completed_;
  bool has_target_completed_;
  ::bes::build_event_stream::BuildEventId::ActionCompletedId action_completed_;
  bool has_action_completed_;
  ::bes::build_event_stream::BuildEventId::UnconfiguredLabelId unconfigured_label_;
  bool has_unconfigured_label_;
  ::bes::build_event_stream::BuildEventId::ConfiguredLabelId configured_label_;
  bool has_configured_label_;
  ::bes::build_event_stream::BuildEventId::TestResultId test_result_;
  bool has_test_result_;
  ::bes::build_event_stream::BuildEventId::TestProgressId test_progress_;
  bool has_test_progress_;
  ::bes::build_event_stream::BuildEventId::TestSummaryId test_summary_;
  bool has_test_summary_;
  ::bes::build_event_stream::BuildEventId::TargetSummaryId target_summary_;
  bool has_target_summary_;
  ::bes::build_event_stream::BuildEventId::BuildFinishedId build_finished_;
  bool has_build_finished_;
  ::bes::build_event_stream::BuildEventId::BuildToolLogsId build_tool_logs_;
  bool has_build_tool_logs_;
  ::bes::build_event_stream::BuildEventId::BuildMetricsId build_metrics_;
  bool has_build_metrics_;
  ::bes::build_event_stream::BuildEventId::WorkspaceConfigId workspace_;
  bool has_workspace_;
  ::bes::build_event_stream::BuildEventId::BuildMetadataId build_metadata_;
  bool has_build_metadata_;
  ::bes::build_event_stream::BuildEventId::ConvenienceSymlinksIdentifiedId convenience_symlinks_identified_;
  bool has_convenience_symlinks_identified_;
  ::bes::build_event_stream::BuildEventId::ExecRequestId exec_request_;
  bool has_exec_request_;

  BuildEventId();
  BuildEventId(const BuildEventId&) = default;
  BuildEventId(BuildEventId&&) = default;
  BuildEventId& operator=(const BuildEventId&) = default;
  BuildEventId& operator=(BuildEventId&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::build_event_stream::BuildEventId::UnknownBuildEventId* mutable_unknown() {
    has_unknown_ = true;
    return &unknown_;
  }
  ::bes::build_event_stream::BuildEventId::ProgressId* mutable_progress() {
    has_progress_ = true;
    return &progress_;
  }
  ::bes::build_event_stream::BuildEventId::BuildStartedId* mutable_started() {
    has_started_ = true;
    return &started_;
  }
  ::bes::build_event_stream::BuildEventId::UnstructuredCommandLineId* mutable_unstructured_command_line() {
    has_unstructured_command_line_ = true;
    return &unstructured_command_line_;
  }
  ::bes::build_event_stream::BuildEventId::StructuredCommandLineId* mutable_structured_command_line() {
    has_structured_command_line_ = true;
    return &structured_command_line_;
  }
  ::bes::build_event_stream::BuildEventId::WorkspaceStatusId* mutable_workspace_status() {
    has_workspace_status_ = true;
    return &workspace_status_;
  }
  ::bes::build_event_stream::BuildEventId::OptionsParsedId* mutable_options_parsed() {
    has_options_parsed_ = true;
    return &options_parsed_;
  }
  ::bes::build_event_stream::BuildEventId::FetchId* mutable_fetch() {
    has_fetch_ = true;
    return &fetch_;
  }
  ::bes::build_event_stream::BuildEventId::ConfigurationId* mutable_configuration() {
    has_configuration_ = true;
    return &configuration_;
  }
  ::bes::build_event_stream::BuildEventId::TargetConfiguredId* mutable_target_configured() {
    has_target_configured_ = true;
    return &target_configured_;
  }
  ::bes::build_event_stream::BuildEventId::PatternExpandedId* mutable_pattern() {
    has_pattern_ = true;
    return &pattern_;
  }
  ::bes::build_event_stream::BuildEventId::PatternExpandedId* mutable_pattern_skipped() {
    has_pattern_skipped_ = true;
    return &pattern_skipped_;
  }
  ::bes::build_event_stream::BuildEventId::NamedSetOfFilesId* mutable_named_set() {
    has_named_set_ = true;
    return &named_set_;
  }
  ::bes::build_event_stream::BuildEventId::TargetCompletedId* mutable_target_completed() {
    has_target_completed_ = true;
    return &target_completed_;
  }
  ::bes::build_event_stream::BuildEventId::ActionCompletedId* mutable_action_completed() {
    has_action_completed_ = true;
    return &action_completed_;
  }
  ::bes::build_event_stream::BuildEventId::UnconfiguredLabelId* mutable_unconfigured_label() {
    has_unconfigured_label_ = true;
    return &unconfigured_label_;
  }
  ::bes::build_event_stream::BuildEventId::ConfiguredLabelId* mutable_configured_label() {
    has_configured_label_ = true;
    return &configured_label_;
  }
  ::bes::build_event_stream::BuildEventId::TestResultId* mutable_test_result() {
    has_test_result_ = true;
    return &test_result_;
  }
  ::bes::build_event_stream::BuildEventId::TestProgressId* mutable_test_progress() {
    has_test_progress_ = true;
    return &test_progress_;
  }
  ::bes::build_event_stream::BuildEventId::TestSummaryId* mutable_test_summary() {
    has_test_summary_ = true;
    return &test_summary_;
  }
  ::bes::build_event_stream::BuildEventId::TargetSummaryId* mutable_target_summary() {
    has_target_summary_ = true;
    return &target_summary_;
  }
  ::bes::build_event_stream::BuildEventId::BuildFinishedId* mutable_build_finished() {
    has_build_finished_ = true;
    return &build_finished_;
  }
  ::bes::build_event_stream::BuildEventId::BuildToolLogsId* mutable_build_tool_logs() {
    has_build_tool_logs_ = true;
    return &build_tool_logs_;
  }
  ::bes::build_event_stream::BuildEventId::BuildMetricsId* mutable_build_metrics() {
    has_build_metrics_ = true;
    return &build_metrics_;
  }
  ::bes::build_event_stream::BuildEventId::WorkspaceConfigId* mutable_workspace() {
    has_workspace_ = true;
    return &workspace_;
  }
  ::bes::build_event_stream::BuildEventId::BuildMetadataId* mutable_build_metadata() {
    has_build_metadata_ = true;
    return &build_metadata_;
  }
  ::bes::build_event_stream::BuildEventId::ConvenienceSymlinksIdentifiedId* mutable_convenience_symlinks_identified() {
    has_convenience_symlinks_identified_ = true;
    return &convenience_symlinks_identified_;
  }
  ::bes::build_event_stream::BuildEventId::ExecRequestId* mutable_exec_request() {
    has_exec_request_ = true;
    return &exec_request_;
  }
};  // struct BuildEventId
struct Progress {
  std::string stdout_;
  bool has_stdout_;
  std::string stderr_;
  bool has_stderr_;

  Progress();
  Progress(const Progress&) = default;
  Progress(Progress&&) = default;
  Progress& operator=(const Progress&) = default;
  Progress& operator=(Progress&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_stdout() {
    has_stdout_ = true;
    return &stdout_;
  }
  void set_stdout(const std::string& value);
  std::string* mutable_stderr() {
    has_stderr_ = true;
    return &stderr_;
  }
  void set_stderr(const std::string& value);
};  // struct Progress
struct Aborted {
  enum AbortReason {
    UNKNOWN = 0,
    USER_INTERRUPTED = 1,
    NO_ANALYZE = 8,
    NO_BUILD = 9,
    TIME_OUT = 2,
    REMOTE_ENVIRONMENT_FAILURE = 3,
    INTERNAL = 4,
    LOADING_FAILURE = 5,
    ANALYSIS_FAILURE = 6,
    SKIPPED = 7,
    INCOMPLETE = 10,
    OUT_OF_MEMORY = 11,
  };

  ::bes::build_event_stream::Aborted::AbortReason reason_;
  bool has_reason_;
  std::string description_;
  bool has_description_;

  Aborted();
  Aborted(const Aborted&) = default;
  Aborted(Aborted&&) = default;
  Aborted& operator=(const Aborted&) = default;
  Aborted& operator=(Aborted&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::build_event_stream::Aborted::AbortReason* mutable_reason() {
    has_reason_ = true;
    return &reason_;
  }
  void set_reason(const ::bes::build_event_stream::Aborted::AbortReason& value);
  std::string* mutable_description() {
    has_description_ = true;
    return &description_;
  }
  void set_description(const std::string& value);
};  // struct Aborted
struct BuildStarted {
  std::string uuid_;
  bool has_uuid_;
  int64_t start_time_millis_;
  bool has_start_time_millis_;
  ::bes::google::protobuf::Timestamp start_time_;
  bool has_start_time_;
  std::string build_tool_version_;
  bool has_build_tool_version_;
  std::string options_description_;
  bool has_options_description_;
  std::string command_;
  bool has_command_;
  std::string working_directory_;
  bool has_working_directory_;
  std::string workspace_directory_;
  bool has_workspace_directory_;
  int64_t server_pid_;
  bool has_server_pid_;

  BuildStarted();
  BuildStarted(const BuildStarted&) = default;
  BuildStarted(BuildStarted&&) = default;
  BuildStarted& operator=(const BuildStarted&) = default;
  BuildStarted& operator=(BuildStarted&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_uuid() {
    has_uuid_ = true;
    return &uuid_;
  }
  void set_uuid(const std::string& value);
  int64_t* mutable_start_time_millis() {
    has_start_time_millis_ = true;
    return &start_time_millis_;
  }
  void set_start_time_millis(const int64_t& value);
  ::bes::google::protobuf::Timestamp* mutable_start_time() {
    has_start_time_ = true;
    return &start_time_;
  }
  std::string* mutable_build_tool_version() {
    has_build_tool_version_ = true;
    return &build_tool_version_;
  }
  void set_build_tool_version(const std::string& value);
  std::string* mutable_options_description() {
    has_options_description_ = true;
    return &options_description_;
  }
  void set_options_description(const std::string& value);
  std::string* mutable_command() {
    has_command_ = true;
    return &command_;
  }
  void set_command(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_workspace_directory() {
    has_workspace_directory_ = true;
    return &workspace_directory_;
  }
  void set_workspace_directory(const std::string& value);
  int64_t* mutable_server_pid() {
    has_server_pid_ = true;
    return &server_pid_;
  }
  void set_server_pid(const int64_t& value);
};  // struct BuildStarted
struct WorkspaceConfig {
  std::string local_exec_root_;
  bool has_local_exec_root_;

  WorkspaceConfig();
  WorkspaceConfig(const WorkspaceConfig&) = default;
  WorkspaceConfig(WorkspaceConfig&&) = default;
  WorkspaceConfig& operator=(const WorkspaceConfig&) = default;
  WorkspaceConfig& operator=(WorkspaceConfig&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_local_exec_root() {
    has_local_exec_root_ = true;
    return &local_exec_root_;
  }
  void set_local_exec_root(const std::string& value);
};  // struct WorkspaceConfig
struct UnstructuredCommandLine {
  std::vector< std::string > args_;
  bool has_args_;

  UnstructuredCommandLine();
  UnstructuredCommandLine(const UnstructuredCommandLine&) = default;
  UnstructuredCommandLine(UnstructuredCommandLine&&) = default;
  UnstructuredCommandLine& operator=(const UnstructuredCommandLine&) = default;
  UnstructuredCommandLine& operator=(UnstructuredCommandLine&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  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);
};  // struct UnstructuredCommandLine
struct OptionsParsed {
  std::vector< std::string > startup_options_;
  bool has_startup_options_;
  std::vector< std::string > explicit_startup_options_;
  bool has_explicit_startup_options_;
  std::vector< std::string > cmd_line_;
  bool has_cmd_line_;
  std::vector< std::string > explicit_cmd_line_;
  bool has_explicit_cmd_line_;
  ::bes::blaze::invocation_policy::InvocationPolicy invocation_policy_;
  bool has_invocation_policy_;
  std::string tool_tag_;
  bool has_tool_tag_;

  OptionsParsed();
  OptionsParsed(const OptionsParsed&) = default;
  OptionsParsed(OptionsParsed&&) = default;
  OptionsParsed& operator=(const OptionsParsed&) = default;
  OptionsParsed& operator=(OptionsParsed&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< std::string >* mutable_startup_options() {
    has_startup_options_ = true;
    return &startup_options_;
  }
  void add_startup_options(const std::string& value);
  void set_startup_options(const std::vector< std::string >& value);
  std::vector< std::string >* mutable_explicit_startup_options() {
    has_explicit_startup_options_ = true;
    return &explicit_startup_options_;
  }
  void add_explicit_startup_options(const std::string& value);
  void set_explicit_startup_options(const std::vector< std::string >& value);
  std::vector< std::string >* mutable_cmd_line() {
    has_cmd_line_ = true;
    return &cmd_line_;
  }
  void add_cmd_line(const std::string& value);
  void set_cmd_line(const std::vector< std::string >& value);
  std::vector< std::string >* mutable_explicit_cmd_line() {
    has_explicit_cmd_line_ = true;
    return &explicit_cmd_line_;
  }
  void add_explicit_cmd_line(const std::string& value);
  void set_explicit_cmd_line(const std::vector< std::string >& value);
  ::bes::blaze::invocation_policy::InvocationPolicy* mutable_invocation_policy() {
    has_invocation_policy_ = true;
    return &invocation_policy_;
  }
  std::string* mutable_tool_tag() {
    has_tool_tag_ = true;
    return &tool_tag_;
  }
  void set_tool_tag(const std::string& value);
};  // struct OptionsParsed
struct Fetch {
  bool success_;
  bool has_success_;

  Fetch();
  Fetch(const Fetch&) = default;
  Fetch(Fetch&&) = default;
  Fetch& operator=(const Fetch&) = default;
  Fetch& operator=(Fetch&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_success() {
    has_success_ = true;
    return &success_;
  }
  void set_success(const bool& value);
};  // struct Fetch
struct WorkspaceStatus {
  struct Item {
    std::string key_;
    bool has_key_;
    std::string value_;
    bool has_value_;

    Item();
    Item(const Item&) = default;
    Item(Item&&) = default;
    Item& operator=(const Item&) = default;
    Item& operator=(Item&&) = default;
    void SerializeToOstream(std::ostream* 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 Item
  std::vector< ::bes::build_event_stream::WorkspaceStatus::Item > item_;
  bool has_item_;

  WorkspaceStatus();
  WorkspaceStatus(const WorkspaceStatus&) = default;
  WorkspaceStatus(WorkspaceStatus&&) = default;
  WorkspaceStatus& operator=(const WorkspaceStatus&) = default;
  WorkspaceStatus& operator=(WorkspaceStatus&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::build_event_stream::WorkspaceStatus::Item >* mutable_item() {
    has_item_ = true;
    return &item_;
  }
  void add_item(const ::bes::build_event_stream::WorkspaceStatus::Item& value);
};  // struct WorkspaceStatus
struct BuildMetadata {
  struct MetadataEntry {
    std::string key_;
    bool has_key_;
    std::string value_;
    bool has_value_;

    MetadataEntry();
    MetadataEntry(const MetadataEntry&) = default;
    MetadataEntry(MetadataEntry&&) = default;
    MetadataEntry& operator=(const MetadataEntry&) = default;
    MetadataEntry& operator=(MetadataEntry&&) = default;
    void SerializeToOstream(std::ostream* 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 MetadataEntry
  std::vector< ::bes::build_event_stream::BuildMetadata::MetadataEntry > metadata_;
  bool has_metadata_;

  BuildMetadata();
  BuildMetadata(const BuildMetadata&) = default;
  BuildMetadata(BuildMetadata&&) = default;
  BuildMetadata& operator=(const BuildMetadata&) = default;
  BuildMetadata& operator=(BuildMetadata&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::build_event_stream::BuildMetadata::MetadataEntry >* mutable_metadata() {
    has_metadata_ = true;
    return &metadata_;
  }
  void add_metadata(const ::bes::build_event_stream::BuildMetadata::MetadataEntry& value);
};  // struct BuildMetadata
struct Configuration {
  struct MakeVariableEntry {
    std::string key_;
    bool has_key_;
    std::string value_;
    bool has_value_;

    MakeVariableEntry();
    MakeVariableEntry(const MakeVariableEntry&) = default;
    MakeVariableEntry(MakeVariableEntry&&) = default;
    MakeVariableEntry& operator=(const MakeVariableEntry&) = default;
    MakeVariableEntry& operator=(MakeVariableEntry&&) = default;
    void SerializeToOstream(std::ostream* 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 MakeVariableEntry
  std::string mnemonic_;
  bool has_mnemonic_;
  std::string platform_name_;
  bool has_platform_name_;
  std::string cpu_;
  bool has_cpu_;
  std::vector< ::bes::build_event_stream::Configuration::MakeVariableEntry > make_variable_;
  bool has_make_variable_;
  bool is_tool_;
  bool has_is_tool_;

  Configuration();
  Configuration(const Configuration&) = default;
  Configuration(Configuration&&) = default;
  Configuration& operator=(const Configuration&) = default;
  Configuration& operator=(Configuration&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_mnemonic() {
    has_mnemonic_ = true;
    return &mnemonic_;
  }
  void set_mnemonic(const std::string& value);
  std::string* mutable_platform_name() {
    has_platform_name_ = true;
    return &platform_name_;
  }
  void set_platform_name(const std::string& value);
  std::string* mutable_cpu() {
    has_cpu_ = true;
    return &cpu_;
  }
  void set_cpu(const std::string& value);
  std::vector< ::bes::build_event_stream::Configuration::MakeVariableEntry >* mutable_make_variable() {
    has_make_variable_ = true;
    return &make_variable_;
  }
  void add_make_variable(const ::bes::build_event_stream::Configuration::MakeVariableEntry& value);
  bool* mutable_is_tool() {
    has_is_tool_ = true;
    return &is_tool_;
  }
  void set_is_tool(const bool& value);
};  // struct Configuration
struct PatternExpanded {
  struct TestSuiteExpansion {
    std::string suite_label_;
    bool has_suite_label_;
    std::vector< std::string > test_labels_;
    bool has_test_labels_;

    TestSuiteExpansion();
    TestSuiteExpansion(const TestSuiteExpansion&) = default;
    TestSuiteExpansion(TestSuiteExpansion&&) = default;
    TestSuiteExpansion& operator=(const TestSuiteExpansion&) = default;
    TestSuiteExpansion& operator=(TestSuiteExpansion&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_suite_label() {
      has_suite_label_ = true;
      return &suite_label_;
    }
    void set_suite_label(const std::string& value);
    std::vector< std::string >* mutable_test_labels() {
      has_test_labels_ = true;
      return &test_labels_;
    }
    void add_test_labels(const std::string& value);
    void set_test_labels(const std::vector< std::string >& value);
  };  // struct TestSuiteExpansion
  std::vector< ::bes::build_event_stream::PatternExpanded::TestSuiteExpansion > test_suite_expansions_;
  bool has_test_suite_expansions_;

  PatternExpanded();
  PatternExpanded(const PatternExpanded&) = default;
  PatternExpanded(PatternExpanded&&) = default;
  PatternExpanded& operator=(const PatternExpanded&) = default;
  PatternExpanded& operator=(PatternExpanded&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::build_event_stream::PatternExpanded::TestSuiteExpansion >* mutable_test_suite_expansions() {
    has_test_suite_expansions_ = true;
    return &test_suite_expansions_;
  }
  void add_test_suite_expansions(const ::bes::build_event_stream::PatternExpanded::TestSuiteExpansion& value);
};  // struct PatternExpanded
struct TargetConfigured {
  std::string target_kind_;
  bool has_target_kind_;
  ::bes::build_event_stream::TestSize test_size_;
  bool has_test_size_;
  std::vector< std::string > tag_;
  bool has_tag_;

  TargetConfigured();
  TargetConfigured(const TargetConfigured&) = default;
  TargetConfigured(TargetConfigured&&) = default;
  TargetConfigured& operator=(const TargetConfigured&) = default;
  TargetConfigured& operator=(TargetConfigured&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_target_kind() {
    has_target_kind_ = true;
    return &target_kind_;
  }
  void set_target_kind(const std::string& value);
  ::bes::build_event_stream::TestSize* mutable_test_size() {
    has_test_size_ = true;
    return &test_size_;
  }
  void set_test_size(const ::bes::build_event_stream::TestSize& value);
  std::vector< std::string >* mutable_tag() {
    has_tag_ = true;
    return &tag_;
  }
  void add_tag(const std::string& value);
  void set_tag(const std::vector< std::string >& value);
};  // struct TargetConfigured
struct File {
  std::vector< std::string > path_prefix_;
  bool has_path_prefix_;
  std::string name_;
  bool has_name_;
  std::string uri_;
  bool has_uri_;
  std::string contents_;
  bool has_contents_;
  std::string symlink_target_path_;
  bool has_symlink_target_path_;
  std::string digest_;
  bool has_digest_;
  int64_t length_;
  bool has_length_;

  File();
  File(const File&) = default;
  File(File&&) = default;
  File& operator=(const File&) = default;
  File& operator=(File&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< std::string >* mutable_path_prefix() {
    has_path_prefix_ = true;
    return &path_prefix_;
  }
  void add_path_prefix(const std::string& value);
  void set_path_prefix(const std::vector< std::string >& value);
  std::string* mutable_name() {
    has_name_ = true;
    return &name_;
  }
  void set_name(const std::string& value);
  std::string* mutable_uri() {
    has_uri_ = true;
    return &uri_;
  }
  void set_uri(const std::string& value);
  std::string* mutable_contents() {
    has_contents_ = true;
    return &contents_;
  }
  void set_contents(const std::string& value);
  std::string* mutable_symlink_target_path() {
    has_symlink_target_path_ = true;
    return &symlink_target_path_;
  }
  void set_symlink_target_path(const std::string& value);
  std::string* mutable_digest() {
    has_digest_ = true;
    return &digest_;
  }
  void set_digest(const std::string& value);
  int64_t* mutable_length() {
    has_length_ = true;
    return &length_;
  }
  void set_length(const int64_t& value);
};  // struct File
struct NamedSetOfFiles {
  std::vector< ::bes::build_event_stream::File > files_;
  bool has_files_;
  std::vector< ::bes::build_event_stream::BuildEventId::NamedSetOfFilesId > file_sets_;
  bool has_file_sets_;

  NamedSetOfFiles();
  NamedSetOfFiles(const NamedSetOfFiles&) = default;
  NamedSetOfFiles(NamedSetOfFiles&&) = default;
  NamedSetOfFiles& operator=(const NamedSetOfFiles&) = default;
  NamedSetOfFiles& operator=(NamedSetOfFiles&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::build_event_stream::File >* mutable_files() {
    has_files_ = true;
    return &files_;
  }
  void add_files(const ::bes::build_event_stream::File& value);
  std::vector< ::bes::build_event_stream::BuildEventId::NamedSetOfFilesId >* mutable_file_sets() {
    has_file_sets_ = true;
    return &file_sets_;
  }
  void add_file_sets(const ::bes::build_event_stream::BuildEventId::NamedSetOfFilesId& value);
};  // struct NamedSetOfFiles
struct ActionExecuted {
  bool success_;
  bool has_success_;
  std::string type_;
  bool has_type_;
  int32_t exit_code_;
  bool has_exit_code_;
  ::bes::build_event_stream::File stdout_;
  bool has_stdout_;
  ::bes::build_event_stream::File stderr_;
  bool has_stderr_;
  std::string label_;
  bool has_label_;
  ::bes::build_event_stream::BuildEventId::ConfigurationId configuration_;
  bool has_configuration_;
  ::bes::build_event_stream::File primary_output_;
  bool has_primary_output_;
  std::vector< std::string > command_line_;
  bool has_command_line_;
  std::vector< ::bes::build_event_stream::File > action_metadata_logs_;
  bool has_action_metadata_logs_;
  ::bes::failure_details::FailureDetail failure_detail_;
  bool has_failure_detail_;
  ::bes::google::protobuf::Timestamp start_time_;
  bool has_start_time_;
  ::bes::google::protobuf::Timestamp end_time_;
  bool has_end_time_;
  std::vector< ::bes::google::protobuf::Any > strategy_details_;
  bool has_strategy_details_;

  ActionExecuted();
  ActionExecuted(const ActionExecuted&) = default;
  ActionExecuted(ActionExecuted&&) = default;
  ActionExecuted& operator=(const ActionExecuted&) = default;
  ActionExecuted& operator=(ActionExecuted&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_success() {
    has_success_ = true;
    return &success_;
  }
  void set_success(const bool& value);
  std::string* mutable_type() {
    has_type_ = true;
    return &type_;
  }
  void set_type(const std::string& value);
  int32_t* mutable_exit_code() {
    has_exit_code_ = true;
    return &exit_code_;
  }
  void set_exit_code(const int32_t& value);
  ::bes::build_event_stream::File* mutable_stdout() {
    has_stdout_ = true;
    return &stdout_;
  }
  ::bes::build_event_stream::File* mutable_stderr() {
    has_stderr_ = true;
    return &stderr_;
  }
  std::string* mutable_label() {
    has_label_ = true;
    return &label_;
  }
  void set_label(const std::string& value);
  ::bes::build_event_stream::BuildEventId::ConfigurationId* mutable_configuration() {
    has_configuration_ = true;
    return &configuration_;
  }
  ::bes::build_event_stream::File* mutable_primary_output() {
    has_primary_output_ = true;
    return &primary_output_;
  }
  std::vector< std::string >* mutable_command_line() {
    has_command_line_ = true;
    return &command_line_;
  }
  void add_command_line(const std::string& value);
  void set_command_line(const std::vector< std::string >& value);
  std::vector< ::bes::build_event_stream::File >* mutable_action_metadata_logs() {
    has_action_metadata_logs_ = true;
    return &action_metadata_logs_;
  }
  void add_action_metadata_logs(const ::bes::build_event_stream::File& value);
  ::bes::failure_details::FailureDetail* mutable_failure_detail() {
    has_failure_detail_ = true;
    return &failure_detail_;
  }
  ::bes::google::protobuf::Timestamp* mutable_start_time() {
    has_start_time_ = true;
    return &start_time_;
  }
  ::bes::google::protobuf::Timestamp* mutable_end_time() {
    has_end_time_ = true;
    return &end_time_;
  }
  std::vector< ::bes::google::protobuf::Any >* mutable_strategy_details() {
    has_strategy_details_ = true;
    return &strategy_details_;
  }
  void add_strategy_details(const ::bes::google::protobuf::Any& value);
};  // struct ActionExecuted
struct OutputGroup {
  std::string name_;
  bool has_name_;
  std::vector< ::bes::build_event_stream::BuildEventId::NamedSetOfFilesId > file_sets_;
  bool has_file_sets_;
  bool incomplete_;
  bool has_incomplete_;
  std::vector< ::bes::build_event_stream::File > inline_files_;
  bool has_inline_files_;

  OutputGroup();
  OutputGroup(const OutputGroup&) = default;
  OutputGroup(OutputGroup&&) = default;
  OutputGroup& operator=(const OutputGroup&) = default;
  OutputGroup& operator=(OutputGroup&&) = default;
  void SerializeToOstream(std::ostream* 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< ::bes::build_event_stream::BuildEventId::NamedSetOfFilesId >* mutable_file_sets() {
    has_file_sets_ = true;
    return &file_sets_;
  }
  void add_file_sets(const ::bes::build_event_stream::BuildEventId::NamedSetOfFilesId& value);
  bool* mutable_incomplete() {
    has_incomplete_ = true;
    return &incomplete_;
  }
  void set_incomplete(const bool& value);
  std::vector< ::bes::build_event_stream::File >* mutable_inline_files() {
    has_inline_files_ = true;
    return &inline_files_;
  }
  void add_inline_files(const ::bes::build_event_stream::File& value);
};  // struct OutputGroup
struct TargetComplete {
  bool success_;
  bool has_success_;
  std::string target_kind_;
  bool has_target_kind_;
  ::bes::build_event_stream::TestSize test_size_;
  bool has_test_size_;
  std::vector< ::bes::build_event_stream::OutputGroup > output_group_;
  bool has_output_group_;
  std::vector< ::bes::build_event_stream::File > important_output_;
  bool has_important_output_;
  std::vector< ::bes::build_event_stream::File > directory_output_;
  bool has_directory_output_;
  std::vector< std::string > tag_;
  bool has_tag_;
  int64_t test_timeout_seconds_;
  bool has_test_timeout_seconds_;
  ::bes::google::protobuf::Duration test_timeout_;
  bool has_test_timeout_;
  ::bes::failure_details::FailureDetail failure_detail_;
  bool has_failure_detail_;

  TargetComplete();
  TargetComplete(const TargetComplete&) = default;
  TargetComplete(TargetComplete&&) = default;
  TargetComplete& operator=(const TargetComplete&) = default;
  TargetComplete& operator=(TargetComplete&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_success() {
    has_success_ = true;
    return &success_;
  }
  void set_success(const bool& value);
  std::string* mutable_target_kind() {
    has_target_kind_ = true;
    return &target_kind_;
  }
  void set_target_kind(const std::string& value);
  ::bes::build_event_stream::TestSize* mutable_test_size() {
    has_test_size_ = true;
    return &test_size_;
  }
  void set_test_size(const ::bes::build_event_stream::TestSize& value);
  std::vector< ::bes::build_event_stream::OutputGroup >* mutable_output_group() {
    has_output_group_ = true;
    return &output_group_;
  }
  void add_output_group(const ::bes::build_event_stream::OutputGroup& value);
  std::vector< ::bes::build_event_stream::File >* mutable_important_output() {
    has_important_output_ = true;
    return &important_output_;
  }
  void add_important_output(const ::bes::build_event_stream::File& value);
  std::vector< ::bes::build_event_stream::File >* mutable_directory_output() {
    has_directory_output_ = true;
    return &directory_output_;
  }
  void add_directory_output(const ::bes::build_event_stream::File& value);
  std::vector< std::string >* mutable_tag() {
    has_tag_ = true;
    return &tag_;
  }
  void add_tag(const std::string& value);
  void set_tag(const std::vector< std::string >& value);
  int64_t* mutable_test_timeout_seconds() {
    has_test_timeout_seconds_ = true;
    return &test_timeout_seconds_;
  }
  void set_test_timeout_seconds(const int64_t& value);
  ::bes::google::protobuf::Duration* mutable_test_timeout() {
    has_test_timeout_ = true;
    return &test_timeout_;
  }
  ::bes::failure_details::FailureDetail* mutable_failure_detail() {
    has_failure_detail_ = true;
    return &failure_detail_;
  }
};  // struct TargetComplete
struct TestResult {
  struct ExecutionInfo {
    struct TimingBreakdown {
      std::vector< ::bes::build_event_stream::TestResult::ExecutionInfo::TimingBreakdown > child_;
      bool has_child_;
      std::string name_;
      bool has_name_;
      int64_t time_millis_;
      bool has_time_millis_;
      ::bes::google::protobuf::Duration time_;
      bool has_time_;

      TimingBreakdown();
      TimingBreakdown(const TimingBreakdown&) = default;
      TimingBreakdown(TimingBreakdown&&) = default;
      TimingBreakdown& operator=(const TimingBreakdown&) = default;
      TimingBreakdown& operator=(TimingBreakdown&&) = default;
      void SerializeToOstream(std::ostream* output__) const;
      size_t ByteSizeLong() const;
      void Clear();
      std::vector< ::bes::build_event_stream::TestResult::ExecutionInfo::TimingBreakdown >* mutable_child() {
        has_child_ = true;
        return &child_;
      }
      void add_child(const ::bes::build_event_stream::TestResult::ExecutionInfo::TimingBreakdown& value);
      std::string* mutable_name() {
        has_name_ = true;
        return &name_;
      }
      void set_name(const std::string& value);
      int64_t* mutable_time_millis() {
        has_time_millis_ = true;
        return &time_millis_;
      }
      void set_time_millis(const int64_t& value);
      ::bes::google::protobuf::Duration* mutable_time() {
        has_time_ = true;
        return &time_;
      }
    };  // struct TimingBreakdown
    struct ResourceUsage {
      std::string name_;
      bool has_name_;
      int64_t value_;
      bool has_value_;

      ResourceUsage();
      ResourceUsage(const ResourceUsage&) = default;
      ResourceUsage(ResourceUsage&&) = default;
      ResourceUsage& operator=(const ResourceUsage&) = default;
      ResourceUsage& operator=(ResourceUsage&&) = default;
      void SerializeToOstream(std::ostream* output__) const;
      size_t ByteSizeLong() const;
      void Clear();
      std::string* mutable_name() {
        has_name_ = true;
        return &name_;
      }
      void set_name(const std::string& value);
      int64_t* mutable_value() {
        has_value_ = true;
        return &value_;
      }
      void set_value(const int64_t& value);
    };  // struct ResourceUsage
    int32_t timeout_seconds_;
    bool has_timeout_seconds_;
    std::string strategy_;
    bool has_strategy_;
    bool cached_remotely_;
    bool has_cached_remotely_;
    int32_t exit_code_;
    bool has_exit_code_;
    std::string hostname_;
    bool has_hostname_;
    ::bes::build_event_stream::TestResult::ExecutionInfo::TimingBreakdown timing_breakdown_;
    bool has_timing_breakdown_;
    std::vector< ::bes::build_event_stream::TestResult::ExecutionInfo::ResourceUsage > resource_usage_;
    bool has_resource_usage_;

    ExecutionInfo();
    ExecutionInfo(const ExecutionInfo&) = default;
    ExecutionInfo(ExecutionInfo&&) = default;
    ExecutionInfo& operator=(const ExecutionInfo&) = default;
    ExecutionInfo& operator=(ExecutionInfo&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int32_t* mutable_timeout_seconds() {
      has_timeout_seconds_ = true;
      return &timeout_seconds_;
    }
    void set_timeout_seconds(const int32_t& value);
    std::string* mutable_strategy() {
      has_strategy_ = true;
      return &strategy_;
    }
    void set_strategy(const std::string& value);
    bool* mutable_cached_remotely() {
      has_cached_remotely_ = true;
      return &cached_remotely_;
    }
    void set_cached_remotely(const bool& 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);
    ::bes::build_event_stream::TestResult::ExecutionInfo::TimingBreakdown* mutable_timing_breakdown() {
      has_timing_breakdown_ = true;
      return &timing_breakdown_;
    }
    std::vector< ::bes::build_event_stream::TestResult::ExecutionInfo::ResourceUsage >* mutable_resource_usage() {
      has_resource_usage_ = true;
      return &resource_usage_;
    }
    void add_resource_usage(const ::bes::build_event_stream::TestResult::ExecutionInfo::ResourceUsage& value);
  };  // struct ExecutionInfo
  ::bes::build_event_stream::TestStatus status_;
  bool has_status_;
  std::string status_details_;
  bool has_status_details_;
  bool cached_locally_;
  bool has_cached_locally_;
  int64_t test_attempt_start_millis_epoch_;
  bool has_test_attempt_start_millis_epoch_;
  ::bes::google::protobuf::Timestamp test_attempt_start_;
  bool has_test_attempt_start_;
  int64_t test_attempt_duration_millis_;
  bool has_test_attempt_duration_millis_;
  ::bes::google::protobuf::Duration test_attempt_duration_;
  bool has_test_attempt_duration_;
  std::vector< ::bes::build_event_stream::File > test_action_output_;
  bool has_test_action_output_;
  std::vector< std::string > warning_;
  bool has_warning_;
  ::bes::build_event_stream::TestResult::ExecutionInfo execution_info_;
  bool has_execution_info_;

  TestResult();
  TestResult(const TestResult&) = default;
  TestResult(TestResult&&) = default;
  TestResult& operator=(const TestResult&) = default;
  TestResult& operator=(TestResult&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::build_event_stream::TestStatus* mutable_status() {
    has_status_ = true;
    return &status_;
  }
  void set_status(const ::bes::build_event_stream::TestStatus& value);
  std::string* mutable_status_details() {
    has_status_details_ = true;
    return &status_details_;
  }
  void set_status_details(const std::string& value);
  bool* mutable_cached_locally() {
    has_cached_locally_ = true;
    return &cached_locally_;
  }
  void set_cached_locally(const bool& value);
  int64_t* mutable_test_attempt_start_millis_epoch() {
    has_test_attempt_start_millis_epoch_ = true;
    return &test_attempt_start_millis_epoch_;
  }
  void set_test_attempt_start_millis_epoch(const int64_t& value);
  ::bes::google::protobuf::Timestamp* mutable_test_attempt_start() {
    has_test_attempt_start_ = true;
    return &test_attempt_start_;
  }
  int64_t* mutable_test_attempt_duration_millis() {
    has_test_attempt_duration_millis_ = true;
    return &test_attempt_duration_millis_;
  }
  void set_test_attempt_duration_millis(const int64_t& value);
  ::bes::google::protobuf::Duration* mutable_test_attempt_duration() {
    has_test_attempt_duration_ = true;
    return &test_attempt_duration_;
  }
  std::vector< ::bes::build_event_stream::File >* mutable_test_action_output() {
    has_test_action_output_ = true;
    return &test_action_output_;
  }
  void add_test_action_output(const ::bes::build_event_stream::File& value);
  std::vector< std::string >* mutable_warning() {
    has_warning_ = true;
    return &warning_;
  }
  void add_warning(const std::string& value);
  void set_warning(const std::vector< std::string >& value);
  ::bes::build_event_stream::TestResult::ExecutionInfo* mutable_execution_info() {
    has_execution_info_ = true;
    return &execution_info_;
  }
};  // struct TestResult
struct TestProgress {
  std::string uri_;
  bool has_uri_;

  TestProgress();
  TestProgress(const TestProgress&) = default;
  TestProgress(TestProgress&&) = default;
  TestProgress& operator=(const TestProgress&) = default;
  TestProgress& operator=(TestProgress&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_uri() {
    has_uri_ = true;
    return &uri_;
  }
  void set_uri(const std::string& value);
};  // struct TestProgress
struct TestSummary {
  ::bes::build_event_stream::TestStatus overall_status_;
  bool has_overall_status_;
  int32_t total_run_count_;
  bool has_total_run_count_;
  int32_t run_count_;
  bool has_run_count_;
  int32_t attempt_count_;
  bool has_attempt_count_;
  int32_t shard_count_;
  bool has_shard_count_;
  std::vector< ::bes::build_event_stream::File > passed_;
  bool has_passed_;
  std::vector< ::bes::build_event_stream::File > failed_;
  bool has_failed_;
  int32_t total_num_cached_;
  bool has_total_num_cached_;
  int64_t first_start_time_millis_;
  bool has_first_start_time_millis_;
  ::bes::google::protobuf::Timestamp first_start_time_;
  bool has_first_start_time_;
  int64_t last_stop_time_millis_;
  bool has_last_stop_time_millis_;
  ::bes::google::protobuf::Timestamp last_stop_time_;
  bool has_last_stop_time_;
  int64_t total_run_duration_millis_;
  bool has_total_run_duration_millis_;
  ::bes::google::protobuf::Duration total_run_duration_;
  bool has_total_run_duration_;

  TestSummary();
  TestSummary(const TestSummary&) = default;
  TestSummary(TestSummary&&) = default;
  TestSummary& operator=(const TestSummary&) = default;
  TestSummary& operator=(TestSummary&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::build_event_stream::TestStatus* mutable_overall_status() {
    has_overall_status_ = true;
    return &overall_status_;
  }
  void set_overall_status(const ::bes::build_event_stream::TestStatus& value);
  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_run_count() {
    has_run_count_ = true;
    return &run_count_;
  }
  void set_run_count(const int32_t& value);
  int32_t* mutable_attempt_count() {
    has_attempt_count_ = true;
    return &attempt_count_;
  }
  void set_attempt_count(const int32_t& value);
  int32_t* mutable_shard_count() {
    has_shard_count_ = true;
    return &shard_count_;
  }
  void set_shard_count(const int32_t& value);
  std::vector< ::bes::build_event_stream::File >* mutable_passed() {
    has_passed_ = true;
    return &passed_;
  }
  void add_passed(const ::bes::build_event_stream::File& value);
  std::vector< ::bes::build_event_stream::File >* mutable_failed() {
    has_failed_ = true;
    return &failed_;
  }
  void add_failed(const ::bes::build_event_stream::File& value);
  int32_t* mutable_total_num_cached() {
    has_total_num_cached_ = true;
    return &total_num_cached_;
  }
  void set_total_num_cached(const int32_t& value);
  int64_t* mutable_first_start_time_millis() {
    has_first_start_time_millis_ = true;
    return &first_start_time_millis_;
  }
  void set_first_start_time_millis(const int64_t& value);
  ::bes::google::protobuf::Timestamp* mutable_first_start_time() {
    has_first_start_time_ = true;
    return &first_start_time_;
  }
  int64_t* mutable_last_stop_time_millis() {
    has_last_stop_time_millis_ = true;
    return &last_stop_time_millis_;
  }
  void set_last_stop_time_millis(const int64_t& value);
  ::bes::google::protobuf::Timestamp* mutable_last_stop_time() {
    has_last_stop_time_ = true;
    return &last_stop_time_;
  }
  int64_t* mutable_total_run_duration_millis() {
    has_total_run_duration_millis_ = true;
    return &total_run_duration_millis_;
  }
  void set_total_run_duration_millis(const int64_t& value);
  ::bes::google::protobuf::Duration* mutable_total_run_duration() {
    has_total_run_duration_ = true;
    return &total_run_duration_;
  }
};  // struct TestSummary
struct TargetSummary {
  bool overall_build_success_;
  bool has_overall_build_success_;
  ::bes::build_event_stream::TestStatus overall_test_status_;
  bool has_overall_test_status_;

  TargetSummary();
  TargetSummary(const TargetSummary&) = default;
  TargetSummary(TargetSummary&&) = default;
  TargetSummary& operator=(const TargetSummary&) = default;
  TargetSummary& operator=(TargetSummary&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_overall_build_success() {
    has_overall_build_success_ = true;
    return &overall_build_success_;
  }
  void set_overall_build_success(const bool& value);
  ::bes::build_event_stream::TestStatus* mutable_overall_test_status() {
    has_overall_test_status_ = true;
    return &overall_test_status_;
  }
  void set_overall_test_status(const ::bes::build_event_stream::TestStatus& value);
};  // struct TargetSummary
struct BuildFinished {
  struct ExitCode {
    std::string name_;
    bool has_name_;
    int32_t code_;
    bool has_code_;

    ExitCode();
    ExitCode(const ExitCode&) = default;
    ExitCode(ExitCode&&) = default;
    ExitCode& operator=(const ExitCode&) = default;
    ExitCode& operator=(ExitCode&&) = default;
    void SerializeToOstream(std::ostream* 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_code() {
      has_code_ = true;
      return &code_;
    }
    void set_code(const int32_t& value);
  };  // struct ExitCode
  struct AnomalyReport {
    bool was_suspended_;
    bool has_was_suspended_;

    AnomalyReport();
    AnomalyReport(const AnomalyReport&) = default;
    AnomalyReport(AnomalyReport&&) = default;
    AnomalyReport& operator=(const AnomalyReport&) = default;
    AnomalyReport& operator=(AnomalyReport&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    bool* mutable_was_suspended() {
      has_was_suspended_ = true;
      return &was_suspended_;
    }
    void set_was_suspended(const bool& value);
  };  // struct AnomalyReport
  bool overall_success_;
  bool has_overall_success_;
  ::bes::build_event_stream::BuildFinished::ExitCode exit_code_;
  bool has_exit_code_;
  int64_t finish_time_millis_;
  bool has_finish_time_millis_;
  ::bes::google::protobuf::Timestamp finish_time_;
  bool has_finish_time_;
  ::bes::build_event_stream::BuildFinished::AnomalyReport anomaly_report_;
  bool has_anomaly_report_;
  ::bes::failure_details::FailureDetail failure_detail_;
  bool has_failure_detail_;

  BuildFinished();
  BuildFinished(const BuildFinished&) = default;
  BuildFinished(BuildFinished&&) = default;
  BuildFinished& operator=(const BuildFinished&) = default;
  BuildFinished& operator=(BuildFinished&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  bool* mutable_overall_success() {
    has_overall_success_ = true;
    return &overall_success_;
  }
  void set_overall_success(const bool& value);
  ::bes::build_event_stream::BuildFinished::ExitCode* mutable_exit_code() {
    has_exit_code_ = true;
    return &exit_code_;
  }
  int64_t* mutable_finish_time_millis() {
    has_finish_time_millis_ = true;
    return &finish_time_millis_;
  }
  void set_finish_time_millis(const int64_t& value);
  ::bes::google::protobuf::Timestamp* mutable_finish_time() {
    has_finish_time_ = true;
    return &finish_time_;
  }
  ::bes::build_event_stream::BuildFinished::AnomalyReport* mutable_anomaly_report() {
    has_anomaly_report_ = true;
    return &anomaly_report_;
  }
  ::bes::failure_details::FailureDetail* mutable_failure_detail() {
    has_failure_detail_ = true;
    return &failure_detail_;
  }
};  // struct BuildFinished
struct BuildMetrics {
  struct ActionSummary {
    struct ActionData {
      std::string mnemonic_;
      bool has_mnemonic_;
      int64_t actions_executed_;
      bool has_actions_executed_;
      int64_t first_started_ms_;
      bool has_first_started_ms_;
      int64_t last_ended_ms_;
      bool has_last_ended_ms_;
      ::bes::google::protobuf::Duration system_time_;
      bool has_system_time_;
      ::bes::google::protobuf::Duration user_time_;
      bool has_user_time_;
      int64_t actions_created_;
      bool has_actions_created_;

      ActionData();
      ActionData(const ActionData&) = default;
      ActionData(ActionData&&) = default;
      ActionData& operator=(const ActionData&) = default;
      ActionData& operator=(ActionData&&) = default;
      void SerializeToOstream(std::ostream* output__) const;
      size_t ByteSizeLong() const;
      void Clear();
      std::string* mutable_mnemonic() {
        has_mnemonic_ = true;
        return &mnemonic_;
      }
      void set_mnemonic(const std::string& value);
      int64_t* mutable_actions_executed() {
        has_actions_executed_ = true;
        return &actions_executed_;
      }
      void set_actions_executed(const int64_t& value);
      int64_t* mutable_first_started_ms() {
        has_first_started_ms_ = true;
        return &first_started_ms_;
      }
      void set_first_started_ms(const int64_t& value);
      int64_t* mutable_last_ended_ms() {
        has_last_ended_ms_ = true;
        return &last_ended_ms_;
      }
      void set_last_ended_ms(const int64_t& value);
      ::bes::google::protobuf::Duration* mutable_system_time() {
        has_system_time_ = true;
        return &system_time_;
      }
      ::bes::google::protobuf::Duration* mutable_user_time() {
        has_user_time_ = true;
        return &user_time_;
      }
      int64_t* mutable_actions_created() {
        has_actions_created_ = true;
        return &actions_created_;
      }
      void set_actions_created(const int64_t& value);
    };  // struct ActionData
    struct RunnerCount {
      std::string name_;
      bool has_name_;
      int32_t count_;
      bool has_count_;
      std::string exec_kind_;
      bool has_exec_kind_;

      RunnerCount();
      RunnerCount(const RunnerCount&) = default;
      RunnerCount(RunnerCount&&) = default;
      RunnerCount& operator=(const RunnerCount&) = default;
      RunnerCount& operator=(RunnerCount&&) = default;
      void SerializeToOstream(std::ostream* 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_count() {
        has_count_ = true;
        return &count_;
      }
      void set_count(const int32_t& value);
      std::string* mutable_exec_kind() {
        has_exec_kind_ = true;
        return &exec_kind_;
      }
      void set_exec_kind(const std::string& value);
    };  // struct RunnerCount
    int64_t actions_created_;
    bool has_actions_created_;
    int64_t actions_created_not_including_aspects_;
    bool has_actions_created_not_including_aspects_;
    int64_t actions_executed_;
    bool has_actions_executed_;
    std::vector< ::bes::build_event_stream::BuildMetrics::ActionSummary::ActionData > action_data_;
    bool has_action_data_;
    int64_t remote_cache_hits_;
    bool has_remote_cache_hits_;
    std::vector< ::bes::build_event_stream::BuildMetrics::ActionSummary::RunnerCount > runner_count_;
    bool has_runner_count_;
    ::bes::blaze::ActionCacheStatistics action_cache_statistics_;
    bool has_action_cache_statistics_;

    ActionSummary();
    ActionSummary(const ActionSummary&) = default;
    ActionSummary(ActionSummary&&) = default;
    ActionSummary& operator=(const ActionSummary&) = default;
    ActionSummary& operator=(ActionSummary&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int64_t* mutable_actions_created() {
      has_actions_created_ = true;
      return &actions_created_;
    }
    void set_actions_created(const int64_t& value);
    int64_t* mutable_actions_created_not_including_aspects() {
      has_actions_created_not_including_aspects_ = true;
      return &actions_created_not_including_aspects_;
    }
    void set_actions_created_not_including_aspects(const int64_t& value);
    int64_t* mutable_actions_executed() {
      has_actions_executed_ = true;
      return &actions_executed_;
    }
    void set_actions_executed(const int64_t& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::ActionSummary::ActionData >* mutable_action_data() {
      has_action_data_ = true;
      return &action_data_;
    }
    void add_action_data(const ::bes::build_event_stream::BuildMetrics::ActionSummary::ActionData& value);
    int64_t* mutable_remote_cache_hits() {
      has_remote_cache_hits_ = true;
      return &remote_cache_hits_;
    }
    void set_remote_cache_hits(const int64_t& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::ActionSummary::RunnerCount >* mutable_runner_count() {
      has_runner_count_ = true;
      return &runner_count_;
    }
    void add_runner_count(const ::bes::build_event_stream::BuildMetrics::ActionSummary::RunnerCount& value);
    ::bes::blaze::ActionCacheStatistics* mutable_action_cache_statistics() {
      has_action_cache_statistics_ = true;
      return &action_cache_statistics_;
    }
  };  // struct ActionSummary
  struct MemoryMetrics {
    struct GarbageMetrics {
      std::string type_;
      bool has_type_;
      int64_t garbage_collected_;
      bool has_garbage_collected_;

      GarbageMetrics();
      GarbageMetrics(const GarbageMetrics&) = default;
      GarbageMetrics(GarbageMetrics&&) = default;
      GarbageMetrics& operator=(const GarbageMetrics&) = default;
      GarbageMetrics& operator=(GarbageMetrics&&) = default;
      void SerializeToOstream(std::ostream* output__) const;
      size_t ByteSizeLong() const;
      void Clear();
      std::string* mutable_type() {
        has_type_ = true;
        return &type_;
      }
      void set_type(const std::string& value);
      int64_t* mutable_garbage_collected() {
        has_garbage_collected_ = true;
        return &garbage_collected_;
      }
      void set_garbage_collected(const int64_t& value);
    };  // struct GarbageMetrics
    int64_t used_heap_size_post_build_;
    bool has_used_heap_size_post_build_;
    int64_t peak_post_gc_heap_size_;
    bool has_peak_post_gc_heap_size_;
    int64_t peak_post_gc_tenured_space_heap_size_;
    bool has_peak_post_gc_tenured_space_heap_size_;
    std::vector< ::bes::build_event_stream::BuildMetrics::MemoryMetrics::GarbageMetrics > garbage_metrics_;
    bool has_garbage_metrics_;

    MemoryMetrics();
    MemoryMetrics(const MemoryMetrics&) = default;
    MemoryMetrics(MemoryMetrics&&) = default;
    MemoryMetrics& operator=(const MemoryMetrics&) = default;
    MemoryMetrics& operator=(MemoryMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int64_t* mutable_used_heap_size_post_build() {
      has_used_heap_size_post_build_ = true;
      return &used_heap_size_post_build_;
    }
    void set_used_heap_size_post_build(const int64_t& value);
    int64_t* mutable_peak_post_gc_heap_size() {
      has_peak_post_gc_heap_size_ = true;
      return &peak_post_gc_heap_size_;
    }
    void set_peak_post_gc_heap_size(const int64_t& value);
    int64_t* mutable_peak_post_gc_tenured_space_heap_size() {
      has_peak_post_gc_tenured_space_heap_size_ = true;
      return &peak_post_gc_tenured_space_heap_size_;
    }
    void set_peak_post_gc_tenured_space_heap_size(const int64_t& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::MemoryMetrics::GarbageMetrics >* mutable_garbage_metrics() {
      has_garbage_metrics_ = true;
      return &garbage_metrics_;
    }
    void add_garbage_metrics(const ::bes::build_event_stream::BuildMetrics::MemoryMetrics::GarbageMetrics& value);
  };  // struct MemoryMetrics
  struct TargetMetrics {
    int64_t targets_loaded_;
    bool has_targets_loaded_;
    int64_t targets_configured_;
    bool has_targets_configured_;
    int64_t targets_configured_not_including_aspects_;
    bool has_targets_configured_not_including_aspects_;

    TargetMetrics();
    TargetMetrics(const TargetMetrics&) = default;
    TargetMetrics(TargetMetrics&&) = default;
    TargetMetrics& operator=(const TargetMetrics&) = default;
    TargetMetrics& operator=(TargetMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int64_t* mutable_targets_loaded() {
      has_targets_loaded_ = true;
      return &targets_loaded_;
    }
    void set_targets_loaded(const int64_t& value);
    int64_t* mutable_targets_configured() {
      has_targets_configured_ = true;
      return &targets_configured_;
    }
    void set_targets_configured(const int64_t& value);
    int64_t* mutable_targets_configured_not_including_aspects() {
      has_targets_configured_not_including_aspects_ = true;
      return &targets_configured_not_including_aspects_;
    }
    void set_targets_configured_not_including_aspects(const int64_t& value);
  };  // struct TargetMetrics
  struct PackageMetrics {
    int64_t packages_loaded_;
    bool has_packages_loaded_;
    std::vector< ::bes::devtools::build::lib::packages::metrics::PackageLoadMetrics > package_load_metrics_;
    bool has_package_load_metrics_;

    PackageMetrics();
    PackageMetrics(const PackageMetrics&) = default;
    PackageMetrics(PackageMetrics&&) = default;
    PackageMetrics& operator=(const PackageMetrics&) = default;
    PackageMetrics& operator=(PackageMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int64_t* mutable_packages_loaded() {
      has_packages_loaded_ = true;
      return &packages_loaded_;
    }
    void set_packages_loaded(const int64_t& value);
    std::vector< ::bes::devtools::build::lib::packages::metrics::PackageLoadMetrics >* mutable_package_load_metrics() {
      has_package_load_metrics_ = true;
      return &package_load_metrics_;
    }
    void add_package_load_metrics(const ::bes::devtools::build::lib::packages::metrics::PackageLoadMetrics& value);
  };  // struct PackageMetrics
  struct TimingMetrics {
    int64_t cpu_time_in_ms_;
    bool has_cpu_time_in_ms_;
    int64_t wall_time_in_ms_;
    bool has_wall_time_in_ms_;
    int64_t analysis_phase_time_in_ms_;
    bool has_analysis_phase_time_in_ms_;
    int64_t execution_phase_time_in_ms_;
    bool has_execution_phase_time_in_ms_;
    int64_t actions_execution_start_in_ms_;
    bool has_actions_execution_start_in_ms_;

    TimingMetrics();
    TimingMetrics(const TimingMetrics&) = default;
    TimingMetrics(TimingMetrics&&) = default;
    TimingMetrics& operator=(const TimingMetrics&) = default;
    TimingMetrics& operator=(TimingMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int64_t* mutable_cpu_time_in_ms() {
      has_cpu_time_in_ms_ = true;
      return &cpu_time_in_ms_;
    }
    void set_cpu_time_in_ms(const int64_t& value);
    int64_t* mutable_wall_time_in_ms() {
      has_wall_time_in_ms_ = true;
      return &wall_time_in_ms_;
    }
    void set_wall_time_in_ms(const int64_t& value);
    int64_t* mutable_analysis_phase_time_in_ms() {
      has_analysis_phase_time_in_ms_ = true;
      return &analysis_phase_time_in_ms_;
    }
    void set_analysis_phase_time_in_ms(const int64_t& value);
    int64_t* mutable_execution_phase_time_in_ms() {
      has_execution_phase_time_in_ms_ = true;
      return &execution_phase_time_in_ms_;
    }
    void set_execution_phase_time_in_ms(const int64_t& value);
    int64_t* mutable_actions_execution_start_in_ms() {
      has_actions_execution_start_in_ms_ = true;
      return &actions_execution_start_in_ms_;
    }
    void set_actions_execution_start_in_ms(const int64_t& value);
  };  // struct TimingMetrics
  struct CumulativeMetrics {
    int32_t num_analyses_;
    bool has_num_analyses_;
    int32_t num_builds_;
    bool has_num_builds_;

    CumulativeMetrics();
    CumulativeMetrics(const CumulativeMetrics&) = default;
    CumulativeMetrics(CumulativeMetrics&&) = default;
    CumulativeMetrics& operator=(const CumulativeMetrics&) = default;
    CumulativeMetrics& operator=(CumulativeMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int32_t* mutable_num_analyses() {
      has_num_analyses_ = true;
      return &num_analyses_;
    }
    void set_num_analyses(const int32_t& value);
    int32_t* mutable_num_builds() {
      has_num_builds_ = true;
      return &num_builds_;
    }
    void set_num_builds(const int32_t& value);
  };  // struct CumulativeMetrics
  struct ArtifactMetrics {
    struct FilesMetric {
      int64_t size_in_bytes_;
      bool has_size_in_bytes_;
      int32_t count_;
      bool has_count_;

      FilesMetric();
      FilesMetric(const FilesMetric&) = default;
      FilesMetric(FilesMetric&&) = default;
      FilesMetric& operator=(const FilesMetric&) = default;
      FilesMetric& operator=(FilesMetric&&) = default;
      void SerializeToOstream(std::ostream* output__) const;
      size_t ByteSizeLong() const;
      void Clear();
      int64_t* mutable_size_in_bytes() {
        has_size_in_bytes_ = true;
        return &size_in_bytes_;
      }
      void set_size_in_bytes(const int64_t& value);
      int32_t* mutable_count() {
        has_count_ = true;
        return &count_;
      }
      void set_count(const int32_t& value);
    };  // struct FilesMetric
    ::bes::build_event_stream::BuildMetrics::ArtifactMetrics::FilesMetric source_artifacts_read_;
    bool has_source_artifacts_read_;
    ::bes::build_event_stream::BuildMetrics::ArtifactMetrics::FilesMetric output_artifacts_seen_;
    bool has_output_artifacts_seen_;
    ::bes::build_event_stream::BuildMetrics::ArtifactMetrics::FilesMetric output_artifacts_from_action_cache_;
    bool has_output_artifacts_from_action_cache_;
    ::bes::build_event_stream::BuildMetrics::ArtifactMetrics::FilesMetric top_level_artifacts_;
    bool has_top_level_artifacts_;

    ArtifactMetrics();
    ArtifactMetrics(const ArtifactMetrics&) = default;
    ArtifactMetrics(ArtifactMetrics&&) = default;
    ArtifactMetrics& operator=(const ArtifactMetrics&) = default;
    ArtifactMetrics& operator=(ArtifactMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    ::bes::build_event_stream::BuildMetrics::ArtifactMetrics::FilesMetric* mutable_source_artifacts_read() {
      has_source_artifacts_read_ = true;
      return &source_artifacts_read_;
    }
    ::bes::build_event_stream::BuildMetrics::ArtifactMetrics::FilesMetric* mutable_output_artifacts_seen() {
      has_output_artifacts_seen_ = true;
      return &output_artifacts_seen_;
    }
    ::bes::build_event_stream::BuildMetrics::ArtifactMetrics::FilesMetric* mutable_output_artifacts_from_action_cache() {
      has_output_artifacts_from_action_cache_ = true;
      return &output_artifacts_from_action_cache_;
    }
    ::bes::build_event_stream::BuildMetrics::ArtifactMetrics::FilesMetric* mutable_top_level_artifacts() {
      has_top_level_artifacts_ = true;
      return &top_level_artifacts_;
    }
  };  // struct ArtifactMetrics
  struct EvaluationStat {
    std::string skyfunction_name_;
    bool has_skyfunction_name_;
    int64_t count_;
    bool has_count_;

    EvaluationStat();
    EvaluationStat(const EvaluationStat&) = default;
    EvaluationStat(EvaluationStat&&) = default;
    EvaluationStat& operator=(const EvaluationStat&) = default;
    EvaluationStat& operator=(EvaluationStat&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::string* mutable_skyfunction_name() {
      has_skyfunction_name_ = true;
      return &skyfunction_name_;
    }
    void set_skyfunction_name(const std::string& value);
    int64_t* mutable_count() {
      has_count_ = true;
      return &count_;
    }
    void set_count(const int64_t& value);
  };  // struct EvaluationStat
  struct BuildGraphMetrics {
    struct RuleClassCount {
      std::string key_;
      bool has_key_;
      std::string rule_class_;
      bool has_rule_class_;
      uint64_t count_;
      bool has_count_;
      uint64_t action_count_;
      bool has_action_count_;

      RuleClassCount();
      RuleClassCount(const RuleClassCount&) = default;
      RuleClassCount(RuleClassCount&&) = default;
      RuleClassCount& operator=(const RuleClassCount&) = default;
      RuleClassCount& operator=(RuleClassCount&&) = default;
      void SerializeToOstream(std::ostream* 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_rule_class() {
        has_rule_class_ = true;
        return &rule_class_;
      }
      void set_rule_class(const std::string& value);
      uint64_t* mutable_count() {
        has_count_ = true;
        return &count_;
      }
      void set_count(const uint64_t& value);
      uint64_t* mutable_action_count() {
        has_action_count_ = true;
        return &action_count_;
      }
      void set_action_count(const uint64_t& value);
    };  // struct RuleClassCount
    struct AspectCount {
      std::string key_;
      bool has_key_;
      std::string aspect_name_;
      bool has_aspect_name_;
      uint64_t count_;
      bool has_count_;
      uint64_t action_count_;
      bool has_action_count_;

      AspectCount();
      AspectCount(const AspectCount&) = default;
      AspectCount(AspectCount&&) = default;
      AspectCount& operator=(const AspectCount&) = default;
      AspectCount& operator=(AspectCount&&) = default;
      void SerializeToOstream(std::ostream* 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_aspect_name() {
        has_aspect_name_ = true;
        return &aspect_name_;
      }
      void set_aspect_name(const std::string& value);
      uint64_t* mutable_count() {
        has_count_ = true;
        return &count_;
      }
      void set_count(const uint64_t& value);
      uint64_t* mutable_action_count() {
        has_action_count_ = true;
        return &action_count_;
      }
      void set_action_count(const uint64_t& value);
    };  // struct AspectCount
    int32_t action_lookup_value_count_;
    bool has_action_lookup_value_count_;
    int32_t action_lookup_value_count_not_including_aspects_;
    bool has_action_lookup_value_count_not_including_aspects_;
    int32_t action_count_;
    bool has_action_count_;
    int32_t action_count_not_including_aspects_;
    bool has_action_count_not_including_aspects_;
    int32_t input_file_configured_target_count_;
    bool has_input_file_configured_target_count_;
    int32_t output_file_configured_target_count_;
    bool has_output_file_configured_target_count_;
    int32_t other_configured_target_count_;
    bool has_other_configured_target_count_;
    int32_t output_artifact_count_;
    bool has_output_artifact_count_;
    int32_t post_invocation_skyframe_node_count_;
    bool has_post_invocation_skyframe_node_count_;
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat > dirtied_values_;
    bool has_dirtied_values_;
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat > changed_values_;
    bool has_changed_values_;
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat > built_values_;
    bool has_built_values_;
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat > cleaned_values_;
    bool has_cleaned_values_;
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat > evaluated_values_;
    bool has_evaluated_values_;
    std::vector< ::bes::build_event_stream::BuildMetrics::BuildGraphMetrics::RuleClassCount > rule_class_;
    bool has_rule_class_;
    std::vector< ::bes::build_event_stream::BuildMetrics::BuildGraphMetrics::AspectCount > aspect_;
    bool has_aspect_;

    BuildGraphMetrics();
    BuildGraphMetrics(const BuildGraphMetrics&) = default;
    BuildGraphMetrics(BuildGraphMetrics&&) = default;
    BuildGraphMetrics& operator=(const BuildGraphMetrics&) = default;
    BuildGraphMetrics& operator=(BuildGraphMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int32_t* mutable_action_lookup_value_count() {
      has_action_lookup_value_count_ = true;
      return &action_lookup_value_count_;
    }
    void set_action_lookup_value_count(const int32_t& value);
    int32_t* mutable_action_lookup_value_count_not_including_aspects() {
      has_action_lookup_value_count_not_including_aspects_ = true;
      return &action_lookup_value_count_not_including_aspects_;
    }
    void set_action_lookup_value_count_not_including_aspects(const int32_t& value);
    int32_t* mutable_action_count() {
      has_action_count_ = true;
      return &action_count_;
    }
    void set_action_count(const int32_t& value);
    int32_t* mutable_action_count_not_including_aspects() {
      has_action_count_not_including_aspects_ = true;
      return &action_count_not_including_aspects_;
    }
    void set_action_count_not_including_aspects(const int32_t& value);
    int32_t* mutable_input_file_configured_target_count() {
      has_input_file_configured_target_count_ = true;
      return &input_file_configured_target_count_;
    }
    void set_input_file_configured_target_count(const int32_t& value);
    int32_t* mutable_output_file_configured_target_count() {
      has_output_file_configured_target_count_ = true;
      return &output_file_configured_target_count_;
    }
    void set_output_file_configured_target_count(const int32_t& value);
    int32_t* mutable_other_configured_target_count() {
      has_other_configured_target_count_ = true;
      return &other_configured_target_count_;
    }
    void set_other_configured_target_count(const int32_t& value);
    int32_t* mutable_output_artifact_count() {
      has_output_artifact_count_ = true;
      return &output_artifact_count_;
    }
    void set_output_artifact_count(const int32_t& value);
    int32_t* mutable_post_invocation_skyframe_node_count() {
      has_post_invocation_skyframe_node_count_ = true;
      return &post_invocation_skyframe_node_count_;
    }
    void set_post_invocation_skyframe_node_count(const int32_t& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat >* mutable_dirtied_values() {
      has_dirtied_values_ = true;
      return &dirtied_values_;
    }
    void add_dirtied_values(const ::bes::build_event_stream::BuildMetrics::EvaluationStat& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat >* mutable_changed_values() {
      has_changed_values_ = true;
      return &changed_values_;
    }
    void add_changed_values(const ::bes::build_event_stream::BuildMetrics::EvaluationStat& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat >* mutable_built_values() {
      has_built_values_ = true;
      return &built_values_;
    }
    void add_built_values(const ::bes::build_event_stream::BuildMetrics::EvaluationStat& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat >* mutable_cleaned_values() {
      has_cleaned_values_ = true;
      return &cleaned_values_;
    }
    void add_cleaned_values(const ::bes::build_event_stream::BuildMetrics::EvaluationStat& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::EvaluationStat >* mutable_evaluated_values() {
      has_evaluated_values_ = true;
      return &evaluated_values_;
    }
    void add_evaluated_values(const ::bes::build_event_stream::BuildMetrics::EvaluationStat& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::BuildGraphMetrics::RuleClassCount >* mutable_rule_class() {
      has_rule_class_ = true;
      return &rule_class_;
    }
    void add_rule_class(const ::bes::build_event_stream::BuildMetrics::BuildGraphMetrics::RuleClassCount& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::BuildGraphMetrics::AspectCount >* mutable_aspect() {
      has_aspect_ = true;
      return &aspect_;
    }
    void add_aspect(const ::bes::build_event_stream::BuildMetrics::BuildGraphMetrics::AspectCount& value);
  };  // struct BuildGraphMetrics
  struct WorkerMetrics {
    enum WorkerStatus {
      NOT_STARTED = 0,
      ALIVE = 1,
      KILLED_DUE_TO_MEMORY_PRESSURE = 2,
      KILLED_UNKNOWN = 3,
      KILLED_DUE_TO_INTERRUPTED_EXCEPTION = 4,
      KILLED_DUE_TO_IO_EXCEPTION = 5,
      KILLED_DUE_TO_USER_EXEC_EXCEPTION = 6,
    };

    struct WorkerStats {
      int64_t collect_time_in_ms_;
      bool has_collect_time_in_ms_;
      int32_t worker_memory_in_kb_;
      bool has_worker_memory_in_kb_;
      int32_t prior_worker_memory_in_kb_;
      bool has_prior_worker_memory_in_kb_;
      int64_t last_action_start_time_in_ms_;
      bool has_last_action_start_time_in_ms_;

      WorkerStats();
      WorkerStats(const WorkerStats&) = default;
      WorkerStats(WorkerStats&&) = default;
      WorkerStats& operator=(const WorkerStats&) = default;
      WorkerStats& operator=(WorkerStats&&) = default;
      void SerializeToOstream(std::ostream* output__) const;
      size_t ByteSizeLong() const;
      void Clear();
      int64_t* mutable_collect_time_in_ms() {
        has_collect_time_in_ms_ = true;
        return &collect_time_in_ms_;
      }
      void set_collect_time_in_ms(const int64_t& value);
      int32_t* mutable_worker_memory_in_kb() {
        has_worker_memory_in_kb_ = true;
        return &worker_memory_in_kb_;
      }
      void set_worker_memory_in_kb(const int32_t& value);
      int32_t* mutable_prior_worker_memory_in_kb() {
        has_prior_worker_memory_in_kb_ = true;
        return &prior_worker_memory_in_kb_;
      }
      void set_prior_worker_memory_in_kb(const int32_t& value);
      int64_t* mutable_last_action_start_time_in_ms() {
        has_last_action_start_time_in_ms_ = true;
        return &last_action_start_time_in_ms_;
      }
      void set_last_action_start_time_in_ms(const int64_t& value);
    };  // struct WorkerStats
    int32_t worker_id_;
    bool has_worker_id_;
    std::vector< uint32_t > worker_ids_;
    bool has_worker_ids_;
    uint32_t process_id_;
    bool has_process_id_;
    std::string mnemonic_;
    bool has_mnemonic_;
    bool is_multiplex_;
    bool has_is_multiplex_;
    bool is_sandbox_;
    bool has_is_sandbox_;
    bool is_measurable_;
    bool has_is_measurable_;
    int64_t worker_key_hash_;
    bool has_worker_key_hash_;
    ::bes::build_event_stream::BuildMetrics::WorkerMetrics::WorkerStatus worker_status_;
    bool has_worker_status_;
    ::bes::failure_details::Worker::Code code_;
    bool has_code_;
    int64_t actions_executed_;
    bool has_actions_executed_;
    int64_t prior_actions_executed_;
    bool has_prior_actions_executed_;
    std::vector< ::bes::build_event_stream::BuildMetrics::WorkerMetrics::WorkerStats > worker_stats_;
    bool has_worker_stats_;

    WorkerMetrics();
    WorkerMetrics(const WorkerMetrics&) = default;
    WorkerMetrics(WorkerMetrics&&) = default;
    WorkerMetrics& operator=(const WorkerMetrics&) = default;
    WorkerMetrics& operator=(WorkerMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    int32_t* mutable_worker_id() {
      has_worker_id_ = true;
      return &worker_id_;
    }
    void set_worker_id(const int32_t& value);
    std::vector< uint32_t >* mutable_worker_ids() {
      has_worker_ids_ = true;
      return &worker_ids_;
    }
    void add_worker_ids(const uint32_t& value);
    void set_worker_ids(const std::vector< uint32_t >& value);
    uint32_t* mutable_process_id() {
      has_process_id_ = true;
      return &process_id_;
    }
    void set_process_id(const uint32_t& value);
    std::string* mutable_mnemonic() {
      has_mnemonic_ = true;
      return &mnemonic_;
    }
    void set_mnemonic(const std::string& value);
    bool* mutable_is_multiplex() {
      has_is_multiplex_ = true;
      return &is_multiplex_;
    }
    void set_is_multiplex(const bool& value);
    bool* mutable_is_sandbox() {
      has_is_sandbox_ = true;
      return &is_sandbox_;
    }
    void set_is_sandbox(const bool& value);
    bool* mutable_is_measurable() {
      has_is_measurable_ = true;
      return &is_measurable_;
    }
    void set_is_measurable(const bool& value);
    int64_t* mutable_worker_key_hash() {
      has_worker_key_hash_ = true;
      return &worker_key_hash_;
    }
    void set_worker_key_hash(const int64_t& value);
    ::bes::build_event_stream::BuildMetrics::WorkerMetrics::WorkerStatus* mutable_worker_status() {
      has_worker_status_ = true;
      return &worker_status_;
    }
    void set_worker_status(const ::bes::build_event_stream::BuildMetrics::WorkerMetrics::WorkerStatus& value);
    ::bes::failure_details::Worker::Code* mutable_code() {
      has_code_ = true;
      return &code_;
    }
    void set_code(const ::bes::failure_details::Worker::Code& value);
    int64_t* mutable_actions_executed() {
      has_actions_executed_ = true;
      return &actions_executed_;
    }
    void set_actions_executed(const int64_t& value);
    int64_t* mutable_prior_actions_executed() {
      has_prior_actions_executed_ = true;
      return &prior_actions_executed_;
    }
    void set_prior_actions_executed(const int64_t& value);
    std::vector< ::bes::build_event_stream::BuildMetrics::WorkerMetrics::WorkerStats >* mutable_worker_stats() {
      has_worker_stats_ = true;
      return &worker_stats_;
    }
    void add_worker_stats(const ::bes::build_event_stream::BuildMetrics::WorkerMetrics::WorkerStats& value);
  };  // struct WorkerMetrics
  struct NetworkMetrics {
    struct SystemNetworkStats {
      uint64_t bytes_sent_;
      bool has_bytes_sent_;
      uint64_t bytes_recv_;
      bool has_bytes_recv_;
      uint64_t packets_sent_;
      bool has_packets_sent_;
      uint64_t packets_recv_;
      bool has_packets_recv_;
      uint64_t peak_bytes_sent_per_sec_;
      bool has_peak_bytes_sent_per_sec_;
      uint64_t peak_bytes_recv_per_sec_;
      bool has_peak_bytes_recv_per_sec_;
      uint64_t peak_packets_sent_per_sec_;
      bool has_peak_packets_sent_per_sec_;
      uint64_t peak_packets_recv_per_sec_;
      bool has_peak_packets_recv_per_sec_;

      SystemNetworkStats();
      SystemNetworkStats(const SystemNetworkStats&) = default;
      SystemNetworkStats(SystemNetworkStats&&) = default;
      SystemNetworkStats& operator=(const SystemNetworkStats&) = default;
      SystemNetworkStats& operator=(SystemNetworkStats&&) = default;
      void SerializeToOstream(std::ostream* output__) const;
      size_t ByteSizeLong() const;
      void Clear();
      uint64_t* mutable_bytes_sent() {
        has_bytes_sent_ = true;
        return &bytes_sent_;
      }
      void set_bytes_sent(const uint64_t& value);
      uint64_t* mutable_bytes_recv() {
        has_bytes_recv_ = true;
        return &bytes_recv_;
      }
      void set_bytes_recv(const uint64_t& value);
      uint64_t* mutable_packets_sent() {
        has_packets_sent_ = true;
        return &packets_sent_;
      }
      void set_packets_sent(const uint64_t& value);
      uint64_t* mutable_packets_recv() {
        has_packets_recv_ = true;
        return &packets_recv_;
      }
      void set_packets_recv(const uint64_t& value);
      uint64_t* mutable_peak_bytes_sent_per_sec() {
        has_peak_bytes_sent_per_sec_ = true;
        return &peak_bytes_sent_per_sec_;
      }
      void set_peak_bytes_sent_per_sec(const uint64_t& value);
      uint64_t* mutable_peak_bytes_recv_per_sec() {
        has_peak_bytes_recv_per_sec_ = true;
        return &peak_bytes_recv_per_sec_;
      }
      void set_peak_bytes_recv_per_sec(const uint64_t& value);
      uint64_t* mutable_peak_packets_sent_per_sec() {
        has_peak_packets_sent_per_sec_ = true;
        return &peak_packets_sent_per_sec_;
      }
      void set_peak_packets_sent_per_sec(const uint64_t& value);
      uint64_t* mutable_peak_packets_recv_per_sec() {
        has_peak_packets_recv_per_sec_ = true;
        return &peak_packets_recv_per_sec_;
      }
      void set_peak_packets_recv_per_sec(const uint64_t& value);
    };  // struct SystemNetworkStats
    ::bes::build_event_stream::BuildMetrics::NetworkMetrics::SystemNetworkStats system_network_stats_;
    bool has_system_network_stats_;

    NetworkMetrics();
    NetworkMetrics(const NetworkMetrics&) = default;
    NetworkMetrics(NetworkMetrics&&) = default;
    NetworkMetrics& operator=(const NetworkMetrics&) = default;
    NetworkMetrics& operator=(NetworkMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    ::bes::build_event_stream::BuildMetrics::NetworkMetrics::SystemNetworkStats* mutable_system_network_stats() {
      has_system_network_stats_ = true;
      return &system_network_stats_;
    }
  };  // struct NetworkMetrics
  struct WorkerPoolMetrics {
    struct WorkerPoolStats {
      int32_t hash_;
      bool has_hash_;
      std::string mnemonic_;
      bool has_mnemonic_;
      int64_t created_count_;
      bool has_created_count_;
      int64_t destroyed_count_;
      bool has_destroyed_count_;
      int64_t evicted_count_;
      bool has_evicted_count_;
      int64_t user_exec_exception_destroyed_count_;
      bool has_user_exec_exception_destroyed_count_;
      int64_t io_exception_destroyed_count_;
      bool has_io_exception_destroyed_count_;
      int64_t interrupted_exception_destroyed_count_;
      bool has_interrupted_exception_destroyed_count_;
      int64_t unknown_destroyed_count_;
      bool has_unknown_destroyed_count_;
      int64_t alive_count_;
      bool has_alive_count_;

      WorkerPoolStats();
      WorkerPoolStats(const WorkerPoolStats&) = default;
      WorkerPoolStats(WorkerPoolStats&&) = default;
      WorkerPoolStats& operator=(const WorkerPoolStats&) = default;
      WorkerPoolStats& operator=(WorkerPoolStats&&) = default;
      void SerializeToOstream(std::ostream* output__) const;
      size_t ByteSizeLong() const;
      void Clear();
      int32_t* mutable_hash() {
        has_hash_ = true;
        return &hash_;
      }
      void set_hash(const int32_t& value);
      std::string* mutable_mnemonic() {
        has_mnemonic_ = true;
        return &mnemonic_;
      }
      void set_mnemonic(const std::string& value);
      int64_t* mutable_created_count() {
        has_created_count_ = true;
        return &created_count_;
      }
      void set_created_count(const int64_t& value);
      int64_t* mutable_destroyed_count() {
        has_destroyed_count_ = true;
        return &destroyed_count_;
      }
      void set_destroyed_count(const int64_t& value);
      int64_t* mutable_evicted_count() {
        has_evicted_count_ = true;
        return &evicted_count_;
      }
      void set_evicted_count(const int64_t& value);
      int64_t* mutable_user_exec_exception_destroyed_count() {
        has_user_exec_exception_destroyed_count_ = true;
        return &user_exec_exception_destroyed_count_;
      }
      void set_user_exec_exception_destroyed_count(const int64_t& value);
      int64_t* mutable_io_exception_destroyed_count() {
        has_io_exception_destroyed_count_ = true;
        return &io_exception_destroyed_count_;
      }
      void set_io_exception_destroyed_count(const int64_t& value);
      int64_t* mutable_interrupted_exception_destroyed_count() {
        has_interrupted_exception_destroyed_count_ = true;
        return &interrupted_exception_destroyed_count_;
      }
      void set_interrupted_exception_destroyed_count(const int64_t& value);
      int64_t* mutable_unknown_destroyed_count() {
        has_unknown_destroyed_count_ = true;
        return &unknown_destroyed_count_;
      }
      void set_unknown_destroyed_count(const int64_t& value);
      int64_t* mutable_alive_count() {
        has_alive_count_ = true;
        return &alive_count_;
      }
      void set_alive_count(const int64_t& value);
    };  // struct WorkerPoolStats
    std::vector< ::bes::build_event_stream::BuildMetrics::WorkerPoolMetrics::WorkerPoolStats > worker_pool_stats_;
    bool has_worker_pool_stats_;

    WorkerPoolMetrics();
    WorkerPoolMetrics(const WorkerPoolMetrics&) = default;
    WorkerPoolMetrics(WorkerPoolMetrics&&) = default;
    WorkerPoolMetrics& operator=(const WorkerPoolMetrics&) = default;
    WorkerPoolMetrics& operator=(WorkerPoolMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::vector< ::bes::build_event_stream::BuildMetrics::WorkerPoolMetrics::WorkerPoolStats >* mutable_worker_pool_stats() {
      has_worker_pool_stats_ = true;
      return &worker_pool_stats_;
    }
    void add_worker_pool_stats(const ::bes::build_event_stream::BuildMetrics::WorkerPoolMetrics::WorkerPoolStats& value);
  };  // struct WorkerPoolMetrics
  struct DynamicExecutionMetrics {
    struct RaceStatistics {
      std::string mnemonic_;
      bool has_mnemonic_;
      std::string local_runner_;
      bool has_local_runner_;
      std::string remote_runner_;
      bool has_remote_runner_;
      int32_t local_wins_;
      bool has_local_wins_;
      int32_t remote_wins_;
      bool has_remote_wins_;

      RaceStatistics();
      RaceStatistics(const RaceStatistics&) = default;
      RaceStatistics(RaceStatistics&&) = default;
      RaceStatistics& operator=(const RaceStatistics&) = default;
      RaceStatistics& operator=(RaceStatistics&&) = default;
      void SerializeToOstream(std::ostream* output__) const;
      size_t ByteSizeLong() const;
      void Clear();
      std::string* mutable_mnemonic() {
        has_mnemonic_ = true;
        return &mnemonic_;
      }
      void set_mnemonic(const std::string& value);
      std::string* mutable_local_runner() {
        has_local_runner_ = true;
        return &local_runner_;
      }
      void set_local_runner(const std::string& value);
      std::string* mutable_remote_runner() {
        has_remote_runner_ = true;
        return &remote_runner_;
      }
      void set_remote_runner(const std::string& value);
      int32_t* mutable_local_wins() {
        has_local_wins_ = true;
        return &local_wins_;
      }
      void set_local_wins(const int32_t& value);
      int32_t* mutable_remote_wins() {
        has_remote_wins_ = true;
        return &remote_wins_;
      }
      void set_remote_wins(const int32_t& value);
    };  // struct RaceStatistics
    std::vector< ::bes::build_event_stream::BuildMetrics::DynamicExecutionMetrics::RaceStatistics > race_statistics_;
    bool has_race_statistics_;

    DynamicExecutionMetrics();
    DynamicExecutionMetrics(const DynamicExecutionMetrics&) = default;
    DynamicExecutionMetrics(DynamicExecutionMetrics&&) = default;
    DynamicExecutionMetrics& operator=(const DynamicExecutionMetrics&) = default;
    DynamicExecutionMetrics& operator=(DynamicExecutionMetrics&&) = default;
    void SerializeToOstream(std::ostream* output__) const;
    size_t ByteSizeLong() const;
    void Clear();
    std::vector< ::bes::build_event_stream::BuildMetrics::DynamicExecutionMetrics::RaceStatistics >* mutable_race_statistics() {
      has_race_statistics_ = true;
      return &race_statistics_;
    }
    void add_race_statistics(const ::bes::build_event_stream::BuildMetrics::DynamicExecutionMetrics::RaceStatistics& value);
  };  // struct DynamicExecutionMetrics
  ::bes::build_event_stream::BuildMetrics::ActionSummary action_summary_;
  bool has_action_summary_;
  ::bes::build_event_stream::BuildMetrics::MemoryMetrics memory_metrics_;
  bool has_memory_metrics_;
  ::bes::build_event_stream::BuildMetrics::TargetMetrics target_metrics_;
  bool has_target_metrics_;
  ::bes::build_event_stream::BuildMetrics::PackageMetrics package_metrics_;
  bool has_package_metrics_;
  ::bes::build_event_stream::BuildMetrics::TimingMetrics timing_metrics_;
  bool has_timing_metrics_;
  ::bes::build_event_stream::BuildMetrics::CumulativeMetrics cumulative_metrics_;
  bool has_cumulative_metrics_;
  ::bes::build_event_stream::BuildMetrics::ArtifactMetrics artifact_metrics_;
  bool has_artifact_metrics_;
  ::bes::build_event_stream::BuildMetrics::BuildGraphMetrics build_graph_metrics_;
  bool has_build_graph_metrics_;
  std::vector< ::bes::build_event_stream::BuildMetrics::WorkerMetrics > worker_metrics_;
  bool has_worker_metrics_;
  ::bes::build_event_stream::BuildMetrics::NetworkMetrics network_metrics_;
  bool has_network_metrics_;
  ::bes::build_event_stream::BuildMetrics::WorkerPoolMetrics worker_pool_metrics_;
  bool has_worker_pool_metrics_;
  ::bes::build_event_stream::BuildMetrics::DynamicExecutionMetrics dynamic_execution_metrics_;
  bool has_dynamic_execution_metrics_;

  BuildMetrics();
  BuildMetrics(const BuildMetrics&) = default;
  BuildMetrics(BuildMetrics&&) = default;
  BuildMetrics& operator=(const BuildMetrics&) = default;
  BuildMetrics& operator=(BuildMetrics&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::build_event_stream::BuildMetrics::ActionSummary* mutable_action_summary() {
    has_action_summary_ = true;
    return &action_summary_;
  }
  ::bes::build_event_stream::BuildMetrics::MemoryMetrics* mutable_memory_metrics() {
    has_memory_metrics_ = true;
    return &memory_metrics_;
  }
  ::bes::build_event_stream::BuildMetrics::TargetMetrics* mutable_target_metrics() {
    has_target_metrics_ = true;
    return &target_metrics_;
  }
  ::bes::build_event_stream::BuildMetrics::PackageMetrics* mutable_package_metrics() {
    has_package_metrics_ = true;
    return &package_metrics_;
  }
  ::bes::build_event_stream::BuildMetrics::TimingMetrics* mutable_timing_metrics() {
    has_timing_metrics_ = true;
    return &timing_metrics_;
  }
  ::bes::build_event_stream::BuildMetrics::CumulativeMetrics* mutable_cumulative_metrics() {
    has_cumulative_metrics_ = true;
    return &cumulative_metrics_;
  }
  ::bes::build_event_stream::BuildMetrics::ArtifactMetrics* mutable_artifact_metrics() {
    has_artifact_metrics_ = true;
    return &artifact_metrics_;
  }
  ::bes::build_event_stream::BuildMetrics::BuildGraphMetrics* mutable_build_graph_metrics() {
    has_build_graph_metrics_ = true;
    return &build_graph_metrics_;
  }
  std::vector< ::bes::build_event_stream::BuildMetrics::WorkerMetrics >* mutable_worker_metrics() {
    has_worker_metrics_ = true;
    return &worker_metrics_;
  }
  void add_worker_metrics(const ::bes::build_event_stream::BuildMetrics::WorkerMetrics& value);
  ::bes::build_event_stream::BuildMetrics::NetworkMetrics* mutable_network_metrics() {
    has_network_metrics_ = true;
    return &network_metrics_;
  }
  ::bes::build_event_stream::BuildMetrics::WorkerPoolMetrics* mutable_worker_pool_metrics() {
    has_worker_pool_metrics_ = true;
    return &worker_pool_metrics_;
  }
  ::bes::build_event_stream::BuildMetrics::DynamicExecutionMetrics* mutable_dynamic_execution_metrics() {
    has_dynamic_execution_metrics_ = true;
    return &dynamic_execution_metrics_;
  }
};  // struct BuildMetrics
struct BuildToolLogs {
  std::vector< ::bes::build_event_stream::File > log_;
  bool has_log_;

  BuildToolLogs();
  BuildToolLogs(const BuildToolLogs&) = default;
  BuildToolLogs(BuildToolLogs&&) = default;
  BuildToolLogs& operator=(const BuildToolLogs&) = default;
  BuildToolLogs& operator=(BuildToolLogs&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::build_event_stream::File >* mutable_log() {
    has_log_ = true;
    return &log_;
  }
  void add_log(const ::bes::build_event_stream::File& value);
};  // struct BuildToolLogs
struct ConvenienceSymlinksIdentified {
  std::vector< ::bes::build_event_stream::ConvenienceSymlink > convenience_symlinks_;
  bool has_convenience_symlinks_;

  ConvenienceSymlinksIdentified();
  ConvenienceSymlinksIdentified(const ConvenienceSymlinksIdentified&) = default;
  ConvenienceSymlinksIdentified(ConvenienceSymlinksIdentified&&) = default;
  ConvenienceSymlinksIdentified& operator=(const ConvenienceSymlinksIdentified&) = default;
  ConvenienceSymlinksIdentified& operator=(ConvenienceSymlinksIdentified&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::vector< ::bes::build_event_stream::ConvenienceSymlink >* mutable_convenience_symlinks() {
    has_convenience_symlinks_ = true;
    return &convenience_symlinks_;
  }
  void add_convenience_symlinks(const ::bes::build_event_stream::ConvenienceSymlink& value);
};  // struct ConvenienceSymlinksIdentified
struct ConvenienceSymlink {
  enum Action {
    UNKNOWN = 0,
    CREATE = 1,
    DELETE = 2,
  };

  std::string path_;
  bool has_path_;
  ::bes::build_event_stream::ConvenienceSymlink::Action action_;
  bool has_action_;
  std::string target_;
  bool has_target_;

  ConvenienceSymlink();
  ConvenienceSymlink(const ConvenienceSymlink&) = default;
  ConvenienceSymlink(ConvenienceSymlink&&) = default;
  ConvenienceSymlink& operator=(const ConvenienceSymlink&) = default;
  ConvenienceSymlink& operator=(ConvenienceSymlink&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_path() {
    has_path_ = true;
    return &path_;
  }
  void set_path(const std::string& value);
  ::bes::build_event_stream::ConvenienceSymlink::Action* mutable_action() {
    has_action_ = true;
    return &action_;
  }
  void set_action(const ::bes::build_event_stream::ConvenienceSymlink::Action& value);
  std::string* mutable_target() {
    has_target_ = true;
    return &target_;
  }
  void set_target(const std::string& value);
};  // struct ConvenienceSymlink
struct ExecRequestConstructed {
  std::string working_directory_;
  bool has_working_directory_;
  std::vector< std::string > argv_;
  bool has_argv_;
  std::vector< ::bes::build_event_stream::EnvironmentVariable > environment_variable_;
  bool has_environment_variable_;
  std::vector< std::string > environment_variable_to_clear_;
  bool has_environment_variable_to_clear_;
  bool should_exec_;
  bool has_should_exec_;

  ExecRequestConstructed();
  ExecRequestConstructed(const ExecRequestConstructed&) = default;
  ExecRequestConstructed(ExecRequestConstructed&&) = default;
  ExecRequestConstructed& operator=(const ExecRequestConstructed&) = default;
  ExecRequestConstructed& operator=(ExecRequestConstructed&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  std::string* mutable_working_directory() {
    has_working_directory_ = true;
    return &working_directory_;
  }
  void set_working_directory(const std::string& value);
  std::vector< std::string >* mutable_argv() {
    has_argv_ = true;
    return &argv_;
  }
  void add_argv(const std::string& value);
  void set_argv(const std::vector< std::string >& value);
  std::vector< ::bes::build_event_stream::EnvironmentVariable >* mutable_environment_variable() {
    has_environment_variable_ = true;
    return &environment_variable_;
  }
  void add_environment_variable(const ::bes::build_event_stream::EnvironmentVariable& value);
  std::vector< std::string >* mutable_environment_variable_to_clear() {
    has_environment_variable_to_clear_ = true;
    return &environment_variable_to_clear_;
  }
  void add_environment_variable_to_clear(const std::string& value);
  void set_environment_variable_to_clear(const std::vector< std::string >& value);
  bool* mutable_should_exec() {
    has_should_exec_ = true;
    return &should_exec_;
  }
  void set_should_exec(const bool& value);
};  // struct ExecRequestConstructed
struct EnvironmentVariable {
  std::string name_;
  bool has_name_;
  std::string value_;
  bool has_value_;

  EnvironmentVariable();
  EnvironmentVariable(const EnvironmentVariable&) = default;
  EnvironmentVariable(EnvironmentVariable&&) = default;
  EnvironmentVariable& operator=(const EnvironmentVariable&) = default;
  EnvironmentVariable& operator=(EnvironmentVariable&&) = default;
  void SerializeToOstream(std::ostream* 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_value() {
    has_value_ = true;
    return &value_;
  }
  void set_value(const std::string& value);
};  // struct EnvironmentVariable
struct BuildEvent {
  ::bes::build_event_stream::BuildEventId id_;
  bool has_id_;
  std::vector< ::bes::build_event_stream::BuildEventId > children_;
  bool has_children_;
  bool last_message_;
  bool has_last_message_;
  ::bes::build_event_stream::Progress progress_;
  bool has_progress_;
  ::bes::build_event_stream::Aborted aborted_;
  bool has_aborted_;
  ::bes::build_event_stream::BuildStarted started_;
  bool has_started_;
  ::bes::build_event_stream::UnstructuredCommandLine unstructured_command_line_;
  bool has_unstructured_command_line_;
  ::bes::command_line::CommandLine structured_command_line_;
  bool has_structured_command_line_;
  ::bes::build_event_stream::OptionsParsed options_parsed_;
  bool has_options_parsed_;
  ::bes::build_event_stream::WorkspaceStatus workspace_status_;
  bool has_workspace_status_;
  ::bes::build_event_stream::Fetch fetch_;
  bool has_fetch_;
  ::bes::build_event_stream::Configuration configuration_;
  bool has_configuration_;
  ::bes::build_event_stream::PatternExpanded expanded_;
  bool has_expanded_;
  ::bes::build_event_stream::TargetConfigured configured_;
  bool has_configured_;
  ::bes::build_event_stream::ActionExecuted action_;
  bool has_action_;
  ::bes::build_event_stream::NamedSetOfFiles named_set_of_files_;
  bool has_named_set_of_files_;
  ::bes::build_event_stream::TargetComplete completed_;
  bool has_completed_;
  ::bes::build_event_stream::TestResult test_result_;
  bool has_test_result_;
  ::bes::build_event_stream::TestProgress test_progress_;
  bool has_test_progress_;
  ::bes::build_event_stream::TestSummary test_summary_;
  bool has_test_summary_;
  ::bes::build_event_stream::TargetSummary target_summary_;
  bool has_target_summary_;
  ::bes::build_event_stream::BuildFinished finished_;
  bool has_finished_;
  ::bes::build_event_stream::BuildToolLogs build_tool_logs_;
  bool has_build_tool_logs_;
  ::bes::build_event_stream::BuildMetrics build_metrics_;
  bool has_build_metrics_;
  ::bes::build_event_stream::WorkspaceConfig workspace_info_;
  bool has_workspace_info_;
  ::bes::build_event_stream::BuildMetadata build_metadata_;
  bool has_build_metadata_;
  ::bes::build_event_stream::ConvenienceSymlinksIdentified convenience_symlinks_identified_;
  bool has_convenience_symlinks_identified_;
  ::bes::build_event_stream::ExecRequestConstructed exec_request_;
  bool has_exec_request_;

  BuildEvent();
  BuildEvent(const BuildEvent&) = default;
  BuildEvent(BuildEvent&&) = default;
  BuildEvent& operator=(const BuildEvent&) = default;
  BuildEvent& operator=(BuildEvent&&) = default;
  void SerializeToOstream(std::ostream* output__) const;
  size_t ByteSizeLong() const;
  void Clear();
  ::bes::build_event_stream::BuildEventId* mutable_id() {
    has_id_ = true;
    return &id_;
  }
  std::vector< ::bes::build_event_stream::BuildEventId >* mutable_children() {
    has_children_ = true;
    return &children_;
  }
  void add_children(const ::bes::build_event_stream::BuildEventId& value);
  bool* mutable_last_message() {
    has_last_message_ = true;
    return &last_message_;
  }
  void set_last_message(const bool& value);
  ::bes::build_event_stream::Progress* mutable_progress() {
    has_progress_ = true;
    return &progress_;
  }
  ::bes::build_event_stream::Aborted* mutable_aborted() {
    has_aborted_ = true;
    return &aborted_;
  }
  ::bes::build_event_stream::BuildStarted* mutable_started() {
    has_started_ = true;
    return &started_;
  }
  ::bes::build_event_stream::UnstructuredCommandLine* mutable_unstructured_command_line() {
    has_unstructured_command_line_ = true;
    return &unstructured_command_line_;
  }
  ::bes::command_line::CommandLine* mutable_structured_command_line() {
    has_structured_command_line_ = true;
    return &structured_command_line_;
  }
  ::bes::build_event_stream::OptionsParsed* mutable_options_parsed() {
    has_options_parsed_ = true;
    return &options_parsed_;
  }
  ::bes::build_event_stream::WorkspaceStatus* mutable_workspace_status() {
    has_workspace_status_ = true;
    return &workspace_status_;
  }
  ::bes::build_event_stream::Fetch* mutable_fetch() {
    has_fetch_ = true;
    return &fetch_;
  }
  ::bes::build_event_stream::Configuration* mutable_configuration() {
    has_configuration_ = true;
    return &configuration_;
  }
  ::bes::build_event_stream::PatternExpanded* mutable_expanded() {
    has_expanded_ = true;
    return &expanded_;
  }
  ::bes::build_event_stream::TargetConfigured* mutable_configured() {
    has_configured_ = true;
    return &configured_;
  }
  ::bes::build_event_stream::ActionExecuted* mutable_action() {
    has_action_ = true;
    return &action_;
  }
  ::bes::build_event_stream::NamedSetOfFiles* mutable_named_set_of_files() {
    has_named_set_of_files_ = true;
    return &named_set_of_files_;
  }
  ::bes::build_event_stream::TargetComplete* mutable_completed() {
    has_completed_ = true;
    return &completed_;
  }
  ::bes::build_event_stream::TestResult* mutable_test_result() {
    has_test_result_ = true;
    return &test_result_;
  }
  ::bes::build_event_stream::TestProgress* mutable_test_progress() {
    has_test_progress_ = true;
    return &test_progress_;
  }
  ::bes::build_event_stream::TestSummary* mutable_test_summary() {
    has_test_summary_ = true;
    return &test_summary_;
  }
  ::bes::build_event_stream::TargetSummary* mutable_target_summary() {
    has_target_summary_ = true;
    return &target_summary_;
  }
  ::bes::build_event_stream::BuildFinished* mutable_finished() {
    has_finished_ = true;
    return &finished_;
  }
  ::bes::build_event_stream::BuildToolLogs* mutable_build_tool_logs() {
    has_build_tool_logs_ = true;
    return &build_tool_logs_;
  }
  ::bes::build_event_stream::BuildMetrics* mutable_build_metrics() {
    has_build_metrics_ = true;
    return &build_metrics_;
  }
  ::bes::build_event_stream::WorkspaceConfig* mutable_workspace_info() {
    has_workspace_info_ = true;
    return &workspace_info_;
  }
  ::bes::build_event_stream::BuildMetadata* mutable_build_metadata() {
    has_build_metadata_ = true;
    return &build_metadata_;
  }
  ::bes::build_event_stream::ConvenienceSymlinksIdentified* mutable_convenience_symlinks_identified() {
    has_convenience_symlinks_identified_ = true;
    return &convenience_symlinks_identified_;
  }
  ::bes::build_event_stream::ExecRequestConstructed* mutable_exec_request() {
    has_exec_request_ = true;
    return &exec_request_;
  }
};  // struct BuildEvent
}  // namespace build_event_stream
}  // namespace bes
#endif  // NINJA_BUILD_EVENT_STREAM_PB_H