src/resultstore_reader.pb.h

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

// clang-format off

#ifndef NINJA_RESULTSTORE_READER_PB_H
#define NINJA_RESULTSTORE_READER_PB_H

#include "resultstore.pb.h"
#include "proto_reader.h"

#include <vector>

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

namespace google {
namespace api {
bool ParseFromStream(InputStream& input, Http* out);
bool operator==(const Http& a, const Http& b);
inline bool operator!=(const Http& a, const Http& b) { return !(a == b); }
bool Diff(const Http& a, const Http& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, CustomHttpPattern* out);
bool operator==(const CustomHttpPattern& a, const CustomHttpPattern& b);
inline bool operator!=(const CustomHttpPattern& a, const CustomHttpPattern& b) { return !(a == b); }
bool Diff(const CustomHttpPattern& a, const CustomHttpPattern& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, HttpRule* out);
bool operator==(const HttpRule& a, const HttpRule& b);
inline bool operator!=(const HttpRule& a, const HttpRule& b) { return !(a == b); }
bool Diff(const HttpRule& a, const HttpRule& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
bool Diff(Edition a, Edition b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, FileDescriptorSet* out);
bool operator==(const FileDescriptorSet& a, const FileDescriptorSet& b);
inline bool operator!=(const FileDescriptorSet& a, const FileDescriptorSet& b) { return !(a == b); }
bool Diff(const FileDescriptorSet& a, const FileDescriptorSet& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FeatureSet* out);
bool operator==(const FeatureSet& a, const FeatureSet& b);
inline bool operator!=(const FeatureSet& a, const FeatureSet& b) { return !(a == b); }
bool Diff(const FeatureSet& a, const FeatureSet& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(FeatureSet::FieldPresence a, FeatureSet::FieldPresence b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(FeatureSet::EnumType a, FeatureSet::EnumType b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(FeatureSet::RepeatedFieldEncoding a, FeatureSet::RepeatedFieldEncoding b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(FeatureSet::Utf8Validation a, FeatureSet::Utf8Validation b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(FeatureSet::MessageEncoding a, FeatureSet::MessageEncoding b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(FeatureSet::JsonFormat a, FeatureSet::JsonFormat b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, FileOptions* out);
bool operator==(const FileOptions& a, const FileOptions& b);
inline bool operator!=(const FileOptions& a, const FileOptions& b) { return !(a == b); }
bool Diff(const FileOptions& a, const FileOptions& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(FileOptions::OptimizeMode a, FileOptions::OptimizeMode b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, SourceCodeInfo* out);
bool operator==(const SourceCodeInfo& a, const SourceCodeInfo& b);
inline bool operator!=(const SourceCodeInfo& a, const SourceCodeInfo& b) { return !(a == b); }
bool Diff(const SourceCodeInfo& a, const SourceCodeInfo& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, SourceCodeInfo::Location* out);
bool operator==(const SourceCodeInfo::Location& a, const SourceCodeInfo::Location& b);
inline bool operator!=(const SourceCodeInfo::Location& a, const SourceCodeInfo::Location& b) { return !(a == b); }
bool Diff(const SourceCodeInfo::Location& a, const SourceCodeInfo::Location& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FileDescriptorProto* out);
bool operator==(const FileDescriptorProto& a, const FileDescriptorProto& b);
inline bool operator!=(const FileDescriptorProto& a, const FileDescriptorProto& b) { return !(a == b); }
bool Diff(const FileDescriptorProto& a, const FileDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, ExtensionRangeOptions* out);
bool operator==(const ExtensionRangeOptions& a, const ExtensionRangeOptions& b);
inline bool operator!=(const ExtensionRangeOptions& a, const ExtensionRangeOptions& b) { return !(a == b); }
bool Diff(const ExtensionRangeOptions& a, const ExtensionRangeOptions& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(ExtensionRangeOptions::VerificationState a, ExtensionRangeOptions::VerificationState b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, ExtensionRangeOptions::Declaration* out);
bool operator==(const ExtensionRangeOptions::Declaration& a, const ExtensionRangeOptions::Declaration& b);
inline bool operator!=(const ExtensionRangeOptions::Declaration& a, const ExtensionRangeOptions::Declaration& b) { return !(a == b); }
bool Diff(const ExtensionRangeOptions::Declaration& a, const ExtensionRangeOptions::Declaration& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, MessageOptions* out);
bool operator==(const MessageOptions& a, const MessageOptions& b);
inline bool operator!=(const MessageOptions& a, const MessageOptions& b) { return !(a == b); }
bool Diff(const MessageOptions& a, const MessageOptions& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, DescriptorProto* out);
bool operator==(const DescriptorProto& a, const DescriptorProto& b);
inline bool operator!=(const DescriptorProto& a, const DescriptorProto& b) { return !(a == b); }
bool Diff(const DescriptorProto& a, const DescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, DescriptorProto::ExtensionRange* out);
bool operator==(const DescriptorProto::ExtensionRange& a, const DescriptorProto::ExtensionRange& b);
inline bool operator!=(const DescriptorProto::ExtensionRange& a, const DescriptorProto::ExtensionRange& b) { return !(a == b); }
bool Diff(const DescriptorProto::ExtensionRange& a, const DescriptorProto::ExtensionRange& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, DescriptorProto::ReservedRange* out);
bool operator==(const DescriptorProto::ReservedRange& a, const DescriptorProto::ReservedRange& b);
inline bool operator!=(const DescriptorProto::ReservedRange& a, const DescriptorProto::ReservedRange& b) { return !(a == b); }
bool Diff(const DescriptorProto::ReservedRange& a, const DescriptorProto::ReservedRange& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FieldOptions* out);
bool operator==(const FieldOptions& a, const FieldOptions& b);
inline bool operator!=(const FieldOptions& a, const FieldOptions& b) { return !(a == b); }
bool Diff(const FieldOptions& a, const FieldOptions& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(FieldOptions::CType a, FieldOptions::CType b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(FieldOptions::JSType a, FieldOptions::JSType b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(FieldOptions::OptionRetention a, FieldOptions::OptionRetention b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(FieldOptions::OptionTargetType a, FieldOptions::OptionTargetType b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, FieldOptions::EditionDefault* out);
bool operator==(const FieldOptions::EditionDefault& a, const FieldOptions::EditionDefault& b);
inline bool operator!=(const FieldOptions::EditionDefault& a, const FieldOptions::EditionDefault& b) { return !(a == b); }
bool Diff(const FieldOptions::EditionDefault& a, const FieldOptions::EditionDefault& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FieldOptions::FeatureSupport* out);
bool operator==(const FieldOptions::FeatureSupport& a, const FieldOptions::FeatureSupport& b);
inline bool operator!=(const FieldOptions::FeatureSupport& a, const FieldOptions::FeatureSupport& b) { return !(a == b); }
bool Diff(const FieldOptions::FeatureSupport& a, const FieldOptions::FeatureSupport& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FieldDescriptorProto* out);
bool operator==(const FieldDescriptorProto& a, const FieldDescriptorProto& b);
inline bool operator!=(const FieldDescriptorProto& a, const FieldDescriptorProto& b) { return !(a == b); }
bool Diff(const FieldDescriptorProto& a, const FieldDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(FieldDescriptorProto::Type a, FieldDescriptorProto::Type b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(FieldDescriptorProto::Label a, FieldDescriptorProto::Label b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, OneofOptions* out);
bool operator==(const OneofOptions& a, const OneofOptions& b);
inline bool operator!=(const OneofOptions& a, const OneofOptions& b) { return !(a == b); }
bool Diff(const OneofOptions& a, const OneofOptions& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, OneofDescriptorProto* out);
bool operator==(const OneofDescriptorProto& a, const OneofDescriptorProto& b);
inline bool operator!=(const OneofDescriptorProto& a, const OneofDescriptorProto& b) { return !(a == b); }
bool Diff(const OneofDescriptorProto& a, const OneofDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, EnumOptions* out);
bool operator==(const EnumOptions& a, const EnumOptions& b);
inline bool operator!=(const EnumOptions& a, const EnumOptions& b) { return !(a == b); }
bool Diff(const EnumOptions& a, const EnumOptions& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, EnumDescriptorProto* out);
bool operator==(const EnumDescriptorProto& a, const EnumDescriptorProto& b);
inline bool operator!=(const EnumDescriptorProto& a, const EnumDescriptorProto& b) { return !(a == b); }
bool Diff(const EnumDescriptorProto& a, const EnumDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, EnumDescriptorProto::EnumReservedRange* out);
bool operator==(const EnumDescriptorProto::EnumReservedRange& a, const EnumDescriptorProto::EnumReservedRange& b);
inline bool operator!=(const EnumDescriptorProto::EnumReservedRange& a, const EnumDescriptorProto::EnumReservedRange& b) { return !(a == b); }
bool Diff(const EnumDescriptorProto::EnumReservedRange& a, const EnumDescriptorProto::EnumReservedRange& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, EnumValueOptions* out);
bool operator==(const EnumValueOptions& a, const EnumValueOptions& b);
inline bool operator!=(const EnumValueOptions& a, const EnumValueOptions& b) { return !(a == b); }
bool Diff(const EnumValueOptions& a, const EnumValueOptions& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, EnumValueDescriptorProto* out);
bool operator==(const EnumValueDescriptorProto& a, const EnumValueDescriptorProto& b);
inline bool operator!=(const EnumValueDescriptorProto& a, const EnumValueDescriptorProto& b) { return !(a == b); }
bool Diff(const EnumValueDescriptorProto& a, const EnumValueDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, ServiceOptions* out);
bool operator==(const ServiceOptions& a, const ServiceOptions& b);
inline bool operator!=(const ServiceOptions& a, const ServiceOptions& b) { return !(a == b); }
bool Diff(const ServiceOptions& a, const ServiceOptions& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, ServiceDescriptorProto* out);
bool operator==(const ServiceDescriptorProto& a, const ServiceDescriptorProto& b);
inline bool operator!=(const ServiceDescriptorProto& a, const ServiceDescriptorProto& b) { return !(a == b); }
bool Diff(const ServiceDescriptorProto& a, const ServiceDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, MethodOptions* out);
bool operator==(const MethodOptions& a, const MethodOptions& b);
inline bool operator!=(const MethodOptions& a, const MethodOptions& b) { return !(a == b); }
bool Diff(const MethodOptions& a, const MethodOptions& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(MethodOptions::IdempotencyLevel a, MethodOptions::IdempotencyLevel b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, MethodDescriptorProto* out);
bool operator==(const MethodDescriptorProto& a, const MethodDescriptorProto& b);
inline bool operator!=(const MethodDescriptorProto& a, const MethodDescriptorProto& b) { return !(a == b); }
bool Diff(const MethodDescriptorProto& a, const MethodDescriptorProto& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UninterpretedOption* out);
bool operator==(const UninterpretedOption& a, const UninterpretedOption& b);
inline bool operator!=(const UninterpretedOption& a, const UninterpretedOption& b) { return !(a == b); }
bool Diff(const UninterpretedOption& a, const UninterpretedOption& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UninterpretedOption::NamePart* out);
bool operator==(const UninterpretedOption::NamePart& a, const UninterpretedOption::NamePart& b);
inline bool operator!=(const UninterpretedOption::NamePart& a, const UninterpretedOption::NamePart& b) { return !(a == b); }
bool Diff(const UninterpretedOption::NamePart& a, const UninterpretedOption::NamePart& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FeatureSetDefaults* out);
bool operator==(const FeatureSetDefaults& a, const FeatureSetDefaults& b);
inline bool operator!=(const FeatureSetDefaults& a, const FeatureSetDefaults& b) { return !(a == b); }
bool Diff(const FeatureSetDefaults& a, const FeatureSetDefaults& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FeatureSetDefaults::FeatureSetEditionDefault* out);
bool operator==(const FeatureSetDefaults::FeatureSetEditionDefault& a, const FeatureSetDefaults::FeatureSetEditionDefault& b);
inline bool operator!=(const FeatureSetDefaults::FeatureSetEditionDefault& a, const FeatureSetDefaults::FeatureSetEditionDefault& b) { return !(a == b); }
bool Diff(const FeatureSetDefaults::FeatureSetEditionDefault& a, const FeatureSetDefaults::FeatureSetEditionDefault& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, GeneratedCodeInfo* out);
bool operator==(const GeneratedCodeInfo& a, const GeneratedCodeInfo& b);
inline bool operator!=(const GeneratedCodeInfo& a, const GeneratedCodeInfo& b) { return !(a == b); }
bool Diff(const GeneratedCodeInfo& a, const GeneratedCodeInfo& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, GeneratedCodeInfo::Annotation* out);
bool operator==(const GeneratedCodeInfo::Annotation& a, const GeneratedCodeInfo::Annotation& b);
inline bool operator!=(const GeneratedCodeInfo::Annotation& a, const GeneratedCodeInfo::Annotation& b) { return !(a == b); }
bool Diff(const GeneratedCodeInfo::Annotation& a, const GeneratedCodeInfo::Annotation& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(GeneratedCodeInfo::Annotation::Semantic a, GeneratedCodeInfo::Annotation::Semantic b, std::vector<std::string>* diffs, const std::string& prefix);
}  // namespace protobuf
}  // namespace google
namespace google {
namespace api {
}  // namespace api
}  // namespace google
namespace google {
namespace api {
bool Diff(LaunchStage a, LaunchStage b, std::vector<std::string>* diffs, const std::string& prefix);
}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, Duration* out);
bool operator==(const Duration& a, const Duration& b);
inline bool operator!=(const Duration& a, const Duration& b) { return !(a == b); }
bool Diff(const Duration& a, const Duration& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace protobuf
}  // namespace google
namespace google {
namespace api {
bool Diff(ClientLibraryOrganization a, ClientLibraryOrganization b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(ClientLibraryDestination a, ClientLibraryDestination b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, SelectiveGapicGeneration* out);
bool operator==(const SelectiveGapicGeneration& a, const SelectiveGapicGeneration& b);
inline bool operator!=(const SelectiveGapicGeneration& a, const SelectiveGapicGeneration& b) { return !(a == b); }
bool Diff(const SelectiveGapicGeneration& a, const SelectiveGapicGeneration& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, CommonLanguageSettings* out);
bool operator==(const CommonLanguageSettings& a, const CommonLanguageSettings& b);
inline bool operator!=(const CommonLanguageSettings& a, const CommonLanguageSettings& b) { return !(a == b); }
bool Diff(const CommonLanguageSettings& a, const CommonLanguageSettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, CppSettings* out);
bool operator==(const CppSettings& a, const CppSettings& b);
inline bool operator!=(const CppSettings& a, const CppSettings& b) { return !(a == b); }
bool Diff(const CppSettings& a, const CppSettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, DotnetSettings* out);
bool operator==(const DotnetSettings& a, const DotnetSettings& b);
inline bool operator!=(const DotnetSettings& a, const DotnetSettings& b) { return !(a == b); }
bool Diff(const DotnetSettings& a, const DotnetSettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, DotnetSettings::RenamedServicesEntry* out);
bool operator==(const DotnetSettings::RenamedServicesEntry& a, const DotnetSettings::RenamedServicesEntry& b);
inline bool operator!=(const DotnetSettings::RenamedServicesEntry& a, const DotnetSettings::RenamedServicesEntry& b) { return !(a == b); }
bool Diff(const DotnetSettings::RenamedServicesEntry& a, const DotnetSettings::RenamedServicesEntry& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, DotnetSettings::RenamedResourcesEntry* out);
bool operator==(const DotnetSettings::RenamedResourcesEntry& a, const DotnetSettings::RenamedResourcesEntry& b);
inline bool operator!=(const DotnetSettings::RenamedResourcesEntry& a, const DotnetSettings::RenamedResourcesEntry& b) { return !(a == b); }
bool Diff(const DotnetSettings::RenamedResourcesEntry& a, const DotnetSettings::RenamedResourcesEntry& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, GoSettings* out);
bool operator==(const GoSettings& a, const GoSettings& b);
inline bool operator!=(const GoSettings& a, const GoSettings& b) { return !(a == b); }
bool Diff(const GoSettings& a, const GoSettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, GoSettings::RenamedServicesEntry* out);
bool operator==(const GoSettings::RenamedServicesEntry& a, const GoSettings::RenamedServicesEntry& b);
inline bool operator!=(const GoSettings::RenamedServicesEntry& a, const GoSettings::RenamedServicesEntry& b) { return !(a == b); }
bool Diff(const GoSettings::RenamedServicesEntry& a, const GoSettings::RenamedServicesEntry& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, JavaSettings* out);
bool operator==(const JavaSettings& a, const JavaSettings& b);
inline bool operator!=(const JavaSettings& a, const JavaSettings& b) { return !(a == b); }
bool Diff(const JavaSettings& a, const JavaSettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, JavaSettings::ServiceClassNamesEntry* out);
bool operator==(const JavaSettings::ServiceClassNamesEntry& a, const JavaSettings::ServiceClassNamesEntry& b);
inline bool operator!=(const JavaSettings::ServiceClassNamesEntry& a, const JavaSettings::ServiceClassNamesEntry& b) { return !(a == b); }
bool Diff(const JavaSettings::ServiceClassNamesEntry& a, const JavaSettings::ServiceClassNamesEntry& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, NodeSettings* out);
bool operator==(const NodeSettings& a, const NodeSettings& b);
inline bool operator!=(const NodeSettings& a, const NodeSettings& b) { return !(a == b); }
bool Diff(const NodeSettings& a, const NodeSettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, PhpSettings* out);
bool operator==(const PhpSettings& a, const PhpSettings& b);
inline bool operator!=(const PhpSettings& a, const PhpSettings& b) { return !(a == b); }
bool Diff(const PhpSettings& a, const PhpSettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, PythonSettings* out);
bool operator==(const PythonSettings& a, const PythonSettings& b);
inline bool operator!=(const PythonSettings& a, const PythonSettings& b) { return !(a == b); }
bool Diff(const PythonSettings& a, const PythonSettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, PythonSettings::ExperimentalFeatures* out);
bool operator==(const PythonSettings::ExperimentalFeatures& a, const PythonSettings::ExperimentalFeatures& b);
inline bool operator!=(const PythonSettings::ExperimentalFeatures& a, const PythonSettings::ExperimentalFeatures& b) { return !(a == b); }
bool Diff(const PythonSettings::ExperimentalFeatures& a, const PythonSettings::ExperimentalFeatures& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, RubySettings* out);
bool operator==(const RubySettings& a, const RubySettings& b);
inline bool operator!=(const RubySettings& a, const RubySettings& b) { return !(a == b); }
bool Diff(const RubySettings& a, const RubySettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, ClientLibrarySettings* out);
bool operator==(const ClientLibrarySettings& a, const ClientLibrarySettings& b);
inline bool operator!=(const ClientLibrarySettings& a, const ClientLibrarySettings& b) { return !(a == b); }
bool Diff(const ClientLibrarySettings& a, const ClientLibrarySettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Publishing* out);
bool operator==(const Publishing& a, const Publishing& b);
inline bool operator!=(const Publishing& a, const Publishing& b) { return !(a == b); }
bool Diff(const Publishing& a, const Publishing& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, MethodSettings* out);
bool operator==(const MethodSettings& a, const MethodSettings& b);
inline bool operator!=(const MethodSettings& a, const MethodSettings& b) { return !(a == b); }
bool Diff(const MethodSettings& a, const MethodSettings& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, MethodSettings::LongRunning* out);
bool operator==(const MethodSettings::LongRunning& a, const MethodSettings::LongRunning& b);
inline bool operator!=(const MethodSettings::LongRunning& a, const MethodSettings::LongRunning& b) { return !(a == b); }
bool Diff(const MethodSettings::LongRunning& a, const MethodSettings::LongRunning& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace api
}  // namespace google
namespace google {
namespace api {
bool Diff(FieldBehavior a, FieldBehavior b, std::vector<std::string>* diffs, const std::string& prefix);
}  // namespace api
}  // namespace google
namespace google {
namespace api {
bool ParseFromStream(InputStream& input, ResourceDescriptor* out);
bool operator==(const ResourceDescriptor& a, const ResourceDescriptor& b);
inline bool operator!=(const ResourceDescriptor& a, const ResourceDescriptor& b) { return !(a == b); }
bool Diff(const ResourceDescriptor& a, const ResourceDescriptor& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(ResourceDescriptor::History a, ResourceDescriptor::History b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(ResourceDescriptor::Style a, ResourceDescriptor::Style b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, ResourceReference* out);
bool operator==(const ResourceReference& a, const ResourceReference& b);
inline bool operator!=(const ResourceReference& a, const ResourceReference& b) { return !(a == b); }
bool Diff(const ResourceReference& a, const ResourceReference& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace api
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, Timestamp* out);
bool operator==(const Timestamp& a, const Timestamp& b);
inline bool operator!=(const Timestamp& a, const Timestamp& b) { return !(a == b); }
bool Diff(const Timestamp& a, const Timestamp& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool Diff(Language a, Language b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(Status a, Status b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(UploadStatus a, UploadStatus b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, StatusAttributes* out);
bool operator==(const StatusAttributes& a, const StatusAttributes& b);
inline bool operator!=(const StatusAttributes& a, const StatusAttributes& b) { return !(a == b); }
bool Diff(const StatusAttributes& a, const StatusAttributes& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Property* out);
bool operator==(const Property& a, const Property& b);
inline bool operator!=(const Property& a, const Property& b) { return !(a == b); }
bool Diff(const Property& a, const Property& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Timing* out);
bool operator==(const Timing& a, const Timing& b);
inline bool operator!=(const Timing& a, const Timing& b) { return !(a == b); }
bool Diff(const Timing& a, const Timing& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Dependency* out);
bool operator==(const Dependency& a, const Dependency& b);
inline bool operator!=(const Dependency& a, const Dependency& b) { return !(a == b); }
bool Diff(const Dependency& a, const Dependency& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Dependency::Id* out);
bool operator==(const Dependency::Id& a, const Dependency::Id& b);
inline bool operator!=(const Dependency::Id& a, const Dependency::Id& b) { return !(a == b); }
bool Diff(const Dependency::Id& a, const Dependency::Id& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, LineCoverage* out);
bool operator==(const LineCoverage& a, const LineCoverage& b);
inline bool operator!=(const LineCoverage& a, const LineCoverage& b) { return !(a == b); }
bool Diff(const LineCoverage& a, const LineCoverage& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, BranchCoverage* out);
bool operator==(const BranchCoverage& a, const BranchCoverage& b);
inline bool operator!=(const BranchCoverage& a, const BranchCoverage& b) { return !(a == b); }
bool Diff(const BranchCoverage& a, const BranchCoverage& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FileCoverage* out);
bool operator==(const FileCoverage& a, const FileCoverage& b);
inline bool operator!=(const FileCoverage& a, const FileCoverage& b) { return !(a == b); }
bool Diff(const FileCoverage& a, const FileCoverage& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, ActionCoverage* out);
bool operator==(const ActionCoverage& a, const ActionCoverage& b);
inline bool operator!=(const ActionCoverage& a, const ActionCoverage& b) { return !(a == b); }
bool Diff(const ActionCoverage& a, const ActionCoverage& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, AggregateCoverage* out);
bool operator==(const AggregateCoverage& a, const AggregateCoverage& b);
inline bool operator!=(const AggregateCoverage& a, const AggregateCoverage& b) { return !(a == b); }
bool Diff(const AggregateCoverage& a, const AggregateCoverage& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, DoubleValue* out);
bool operator==(const DoubleValue& a, const DoubleValue& b);
inline bool operator!=(const DoubleValue& a, const DoubleValue& b) { return !(a == b); }
bool Diff(const DoubleValue& a, const DoubleValue& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FloatValue* out);
bool operator==(const FloatValue& a, const FloatValue& b);
inline bool operator!=(const FloatValue& a, const FloatValue& b) { return !(a == b); }
bool Diff(const FloatValue& a, const FloatValue& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Int64Value* out);
bool operator==(const Int64Value& a, const Int64Value& b);
inline bool operator!=(const Int64Value& a, const Int64Value& b) { return !(a == b); }
bool Diff(const Int64Value& a, const Int64Value& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UInt64Value* out);
bool operator==(const UInt64Value& a, const UInt64Value& b);
inline bool operator!=(const UInt64Value& a, const UInt64Value& b) { return !(a == b); }
bool Diff(const UInt64Value& a, const UInt64Value& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Int32Value* out);
bool operator==(const Int32Value& a, const Int32Value& b);
inline bool operator!=(const Int32Value& a, const Int32Value& b) { return !(a == b); }
bool Diff(const Int32Value& a, const Int32Value& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UInt32Value* out);
bool operator==(const UInt32Value& a, const UInt32Value& b);
inline bool operator!=(const UInt32Value& a, const UInt32Value& b) { return !(a == b); }
bool Diff(const UInt32Value& a, const UInt32Value& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, BoolValue* out);
bool operator==(const BoolValue& a, const BoolValue& b);
inline bool operator!=(const BoolValue& a, const BoolValue& b) { return !(a == b); }
bool Diff(const BoolValue& a, const BoolValue& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, StringValue* out);
bool operator==(const StringValue& a, const StringValue& b);
inline bool operator!=(const StringValue& a, const StringValue& b) { return !(a == b); }
bool Diff(const StringValue& a, const StringValue& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, BytesValue* out);
bool operator==(const BytesValue& a, const BytesValue& b);
inline bool operator!=(const BytesValue& a, const BytesValue& b) { return !(a == b); }
bool Diff(const BytesValue& a, const BytesValue& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, ArchiveEntry* out);
bool operator==(const ArchiveEntry& a, const ArchiveEntry& b);
inline bool operator!=(const ArchiveEntry& a, const ArchiveEntry& b) { return !(a == b); }
bool Diff(const ArchiveEntry& a, const ArchiveEntry& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, File* out);
bool operator==(const File& a, const File& b);
inline bool operator!=(const File& a, const File& b) { return !(a == b); }
bool Diff(const File& a, const File& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(File::HashType a, File::HashType b, std::vector<std::string>* diffs, const std::string& prefix);
}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool Diff(FileProcessingErrorType a, FileProcessingErrorType b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, FileProcessingErrors* out);
bool operator==(const FileProcessingErrors& a, const FileProcessingErrors& b);
inline bool operator!=(const FileProcessingErrors& a, const FileProcessingErrors& b) { return !(a == b); }
bool Diff(const FileProcessingErrors& a, const FileProcessingErrors& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FileProcessingError* out);
bool operator==(const FileProcessingError& a, const FileProcessingError& b);
inline bool operator!=(const FileProcessingError& a, const FileProcessingError& b) { return !(a == b); }
bool Diff(const FileProcessingError& a, const FileProcessingError& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, TestSuite* out);
bool operator==(const TestSuite& a, const TestSuite& b);
inline bool operator!=(const TestSuite& a, const TestSuite& b) { return !(a == b); }
bool Diff(const TestSuite& a, const TestSuite& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, TestCase* out);
bool operator==(const TestCase& a, const TestCase& b);
inline bool operator!=(const TestCase& a, const TestCase& b) { return !(a == b); }
bool Diff(const TestCase& a, const TestCase& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(TestCase::Result a, TestCase::Result b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, Test* out);
bool operator==(const Test& a, const Test& b);
inline bool operator!=(const Test& a, const Test& b) { return !(a == b); }
bool Diff(const Test& a, const Test& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, TestFailure* out);
bool operator==(const TestFailure& a, const TestFailure& b);
inline bool operator!=(const TestFailure& a, const TestFailure& b) { return !(a == b); }
bool Diff(const TestFailure& a, const TestFailure& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, TestError* out);
bool operator==(const TestError& a, const TestError& b);
inline bool operator!=(const TestError& a, const TestError& b) { return !(a == b); }
bool Diff(const TestError& a, const TestError& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool Diff(ExecutionStrategy a, ExecutionStrategy b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(TestCaching a, TestCaching b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, InputFileInfo* out);
bool operator==(const InputFileInfo& a, const InputFileInfo& b);
inline bool operator!=(const InputFileInfo& a, const InputFileInfo& b) { return !(a == b); }
bool Diff(const InputFileInfo& a, const InputFileInfo& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, ActionAttributes* out);
bool operator==(const ActionAttributes& a, const ActionAttributes& b);
inline bool operator!=(const ActionAttributes& a, const ActionAttributes& b) { return !(a == b); }
bool Diff(const ActionAttributes& a, const ActionAttributes& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, BuildAction* out);
bool operator==(const BuildAction& a, const BuildAction& b);
inline bool operator!=(const BuildAction& a, const BuildAction& b) { return !(a == b); }
bool Diff(const BuildAction& a, const BuildAction& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, LocalTestTiming* out);
bool operator==(const LocalTestTiming& a, const LocalTestTiming& b);
inline bool operator!=(const LocalTestTiming& a, const LocalTestTiming& b) { return !(a == b); }
bool Diff(const LocalTestTiming& a, const LocalTestTiming& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, RemoteTestTiming* out);
bool operator==(const RemoteTestTiming& a, const RemoteTestTiming& b);
inline bool operator!=(const RemoteTestTiming& a, const RemoteTestTiming& b) { return !(a == b); }
bool Diff(const RemoteTestTiming& a, const RemoteTestTiming& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, TestTiming* out);
bool operator==(const TestTiming& a, const TestTiming& b);
inline bool operator!=(const TestTiming& a, const TestTiming& b) { return !(a == b); }
bool Diff(const TestTiming& a, const TestTiming& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, TestAction* out);
bool operator==(const TestAction& a, const TestAction& b);
inline bool operator!=(const TestAction& a, const TestAction& b) { return !(a == b); }
bool Diff(const TestAction& a, const TestAction& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Action* out);
bool operator==(const Action& a, const Action& b);
inline bool operator!=(const Action& a, const Action& b) { return !(a == b); }
bool Diff(const Action& a, const Action& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Action::Id* out);
bool operator==(const Action::Id& a, const Action::Id& b);
inline bool operator!=(const Action::Id& a, const Action::Id& b) { return !(a == b); }
bool Diff(const Action::Id& a, const Action::Id& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, RemoteTestAttemptTiming* out);
bool operator==(const RemoteTestAttemptTiming& a, const RemoteTestAttemptTiming& b);
inline bool operator!=(const RemoteTestAttemptTiming& a, const RemoteTestAttemptTiming& b) { return !(a == b); }
bool Diff(const RemoteTestAttemptTiming& a, const RemoteTestAttemptTiming& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, TestWarning* out);
bool operator==(const TestWarning& a, const TestWarning& b);
inline bool operator!=(const TestWarning& a, const TestWarning& b) { return !(a == b); }
bool Diff(const TestWarning& a, const TestWarning& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, ConfigurationAttributes* out);
bool operator==(const ConfigurationAttributes& a, const ConfigurationAttributes& b);
inline bool operator!=(const ConfigurationAttributes& a, const ConfigurationAttributes& b) { return !(a == b); }
bool Diff(const ConfigurationAttributes& a, const ConfigurationAttributes& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Configuration* out);
bool operator==(const Configuration& a, const Configuration& b);
inline bool operator!=(const Configuration& a, const Configuration& b) { return !(a == b); }
bool Diff(const Configuration& a, const Configuration& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Configuration::Id* out);
bool operator==(const Configuration::Id& a, const Configuration::Id& b);
inline bool operator!=(const Configuration::Id& a, const Configuration::Id& b) { return !(a == b); }
bool Diff(const Configuration::Id& a, const Configuration::Id& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, ConfiguredTestAttributes* out);
bool operator==(const ConfiguredTestAttributes& a, const ConfiguredTestAttributes& b);
inline bool operator!=(const ConfiguredTestAttributes& a, const ConfiguredTestAttributes& b) { return !(a == b); }
bool Diff(const ConfiguredTestAttributes& a, const ConfiguredTestAttributes& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, ConfiguredTarget* out);
bool operator==(const ConfiguredTarget& a, const ConfiguredTarget& b);
inline bool operator!=(const ConfiguredTarget& a, const ConfiguredTarget& b) { return !(a == b); }
bool Diff(const ConfiguredTarget& a, const ConfiguredTarget& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, ConfiguredTarget::Id* out);
bool operator==(const ConfiguredTarget::Id& a, const ConfiguredTarget::Id& b);
inline bool operator!=(const ConfiguredTarget::Id& a, const ConfiguredTarget::Id& b) { return !(a == b); }
bool Diff(const ConfiguredTarget::Id& a, const ConfiguredTarget::Id& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, FileSet* out);
bool operator==(const FileSet& a, const FileSet& b);
inline bool operator!=(const FileSet& a, const FileSet& b) { return !(a == b); }
bool Diff(const FileSet& a, const FileSet& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FileSet::Id* out);
bool operator==(const FileSet::Id& a, const FileSet::Id& b);
inline bool operator!=(const FileSet::Id& a, const FileSet::Id& b) { return !(a == b); }
bool Diff(const FileSet::Id& a, const FileSet::Id& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, LineCoverageSummary* out);
bool operator==(const LineCoverageSummary& a, const LineCoverageSummary& b);
inline bool operator!=(const LineCoverageSummary& a, const LineCoverageSummary& b) { return !(a == b); }
bool Diff(const LineCoverageSummary& a, const LineCoverageSummary& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, BranchCoverageSummary* out);
bool operator==(const BranchCoverageSummary& a, const BranchCoverageSummary& b);
inline bool operator!=(const BranchCoverageSummary& a, const BranchCoverageSummary& b) { return !(a == b); }
bool Diff(const BranchCoverageSummary& a, const BranchCoverageSummary& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, LanguageCoverageSummary* out);
bool operator==(const LanguageCoverageSummary& a, const LanguageCoverageSummary& b);
inline bool operator!=(const LanguageCoverageSummary& a, const LanguageCoverageSummary& b) { return !(a == b); }
bool Diff(const LanguageCoverageSummary& a, const LanguageCoverageSummary& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, InvocationAttributes* out);
bool operator==(const InvocationAttributes& a, const InvocationAttributes& b);
inline bool operator!=(const InvocationAttributes& a, const InvocationAttributes& b) { return !(a == b); }
bool Diff(const InvocationAttributes& a, const InvocationAttributes& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, WorkspaceContext* out);
bool operator==(const WorkspaceContext& a, const WorkspaceContext& b);
inline bool operator!=(const WorkspaceContext& a, const WorkspaceContext& b) { return !(a == b); }
bool Diff(const WorkspaceContext& a, const WorkspaceContext& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, WorkspaceInfo* out);
bool operator==(const WorkspaceInfo& a, const WorkspaceInfo& b);
inline bool operator!=(const WorkspaceInfo& a, const WorkspaceInfo& b) { return !(a == b); }
bool Diff(const WorkspaceInfo& a, const WorkspaceInfo& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Invocation* out);
bool operator==(const Invocation& a, const Invocation& b);
inline bool operator!=(const Invocation& a, const Invocation& b) { return !(a == b); }
bool Diff(const Invocation& a, const Invocation& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Invocation::Id* out);
bool operator==(const Invocation::Id& a, const Invocation::Id& b);
inline bool operator!=(const Invocation::Id& a, const Invocation::Id& b) { return !(a == b); }
bool Diff(const Invocation::Id& a, const Invocation::Id& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, CommandLine* out);
bool operator==(const CommandLine& a, const CommandLine& b);
inline bool operator!=(const CommandLine& a, const CommandLine& b) { return !(a == b); }
bool Diff(const CommandLine& a, const CommandLine& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, InvocationContext* out);
bool operator==(const InvocationContext& a, const InvocationContext& b);
inline bool operator!=(const InvocationContext& a, const InvocationContext& b) { return !(a == b); }
bool Diff(const InvocationContext& a, const InvocationContext& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool Diff(TargetType a, TargetType b, std::vector<std::string>* diffs, const std::string& prefix);
bool Diff(TestSize a, TestSize b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, TargetAttributes* out);
bool operator==(const TargetAttributes& a, const TargetAttributes& b);
inline bool operator!=(const TargetAttributes& a, const TargetAttributes& b) { return !(a == b); }
bool Diff(const TargetAttributes& a, const TargetAttributes& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, TestAttributes* out);
bool operator==(const TestAttributes& a, const TestAttributes& b);
inline bool operator!=(const TestAttributes& a, const TestAttributes& b) { return !(a == b); }
bool Diff(const TestAttributes& a, const TestAttributes& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Target* out);
bool operator==(const Target& a, const Target& b);
inline bool operator!=(const Target& a, const Target& b) { return !(a == b); }
bool Diff(const Target& a, const Target& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, Target::Id* out);
bool operator==(const Target::Id& a, const Target::Id& b);
inline bool operator!=(const Target::Id& a, const Target::Id& b) { return !(a == b); }
bool Diff(const Target::Id& a, const Target::Id& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, UploadMetadata* out);
bool operator==(const UploadMetadata& a, const UploadMetadata& b);
inline bool operator!=(const UploadMetadata& a, const UploadMetadata& b) { return !(a == b); }
bool Diff(const UploadMetadata& a, const UploadMetadata& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, Empty* out);
bool operator==(const Empty& a, const Empty& b);
inline bool operator!=(const Empty& a, const Empty& b) { return !(a == b); }
bool Diff(const Empty& a, const Empty& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace protobuf
}  // namespace google
namespace google {
namespace protobuf {
bool ParseFromStream(InputStream& input, FieldMask* out);
bool operator==(const FieldMask& a, const FieldMask& b);
inline bool operator!=(const FieldMask& a, const FieldMask& b) { return !(a == b); }
bool Diff(const FieldMask& a, const FieldMask& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace protobuf
}  // namespace google
namespace google {
namespace devtools {
namespace resultstore {
namespace v2 {
bool ParseFromStream(InputStream& input, CreateInvocationRequest* out);
bool operator==(const CreateInvocationRequest& a, const CreateInvocationRequest& b);
inline bool operator!=(const CreateInvocationRequest& a, const CreateInvocationRequest& b) { return !(a == b); }
bool Diff(const CreateInvocationRequest& a, const CreateInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UpdateInvocationRequest* out);
bool operator==(const UpdateInvocationRequest& a, const UpdateInvocationRequest& b);
inline bool operator!=(const UpdateInvocationRequest& a, const UpdateInvocationRequest& b) { return !(a == b); }
bool Diff(const UpdateInvocationRequest& a, const UpdateInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, MergeInvocationRequest* out);
bool operator==(const MergeInvocationRequest& a, const MergeInvocationRequest& b);
inline bool operator!=(const MergeInvocationRequest& a, const MergeInvocationRequest& b) { return !(a == b); }
bool Diff(const MergeInvocationRequest& a, const MergeInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, TouchInvocationRequest* out);
bool operator==(const TouchInvocationRequest& a, const TouchInvocationRequest& b);
inline bool operator!=(const TouchInvocationRequest& a, const TouchInvocationRequest& b) { return !(a == b); }
bool Diff(const TouchInvocationRequest& a, const TouchInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, TouchInvocationResponse* out);
bool operator==(const TouchInvocationResponse& a, const TouchInvocationResponse& b);
inline bool operator!=(const TouchInvocationResponse& a, const TouchInvocationResponse& b) { return !(a == b); }
bool Diff(const TouchInvocationResponse& a, const TouchInvocationResponse& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, DeleteInvocationRequest* out);
bool operator==(const DeleteInvocationRequest& a, const DeleteInvocationRequest& b);
inline bool operator!=(const DeleteInvocationRequest& a, const DeleteInvocationRequest& b) { return !(a == b); }
bool Diff(const DeleteInvocationRequest& a, const DeleteInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FinalizeInvocationRequest* out);
bool operator==(const FinalizeInvocationRequest& a, const FinalizeInvocationRequest& b);
inline bool operator!=(const FinalizeInvocationRequest& a, const FinalizeInvocationRequest& b) { return !(a == b); }
bool Diff(const FinalizeInvocationRequest& a, const FinalizeInvocationRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FinalizeInvocationResponse* out);
bool operator==(const FinalizeInvocationResponse& a, const FinalizeInvocationResponse& b);
inline bool operator!=(const FinalizeInvocationResponse& a, const FinalizeInvocationResponse& b) { return !(a == b); }
bool Diff(const FinalizeInvocationResponse& a, const FinalizeInvocationResponse& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, CreateTargetRequest* out);
bool operator==(const CreateTargetRequest& a, const CreateTargetRequest& b);
inline bool operator!=(const CreateTargetRequest& a, const CreateTargetRequest& b) { return !(a == b); }
bool Diff(const CreateTargetRequest& a, const CreateTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UpdateTargetRequest* out);
bool operator==(const UpdateTargetRequest& a, const UpdateTargetRequest& b);
inline bool operator!=(const UpdateTargetRequest& a, const UpdateTargetRequest& b) { return !(a == b); }
bool Diff(const UpdateTargetRequest& a, const UpdateTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, MergeTargetRequest* out);
bool operator==(const MergeTargetRequest& a, const MergeTargetRequest& b);
inline bool operator!=(const MergeTargetRequest& a, const MergeTargetRequest& b) { return !(a == b); }
bool Diff(const MergeTargetRequest& a, const MergeTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FinalizeTargetRequest* out);
bool operator==(const FinalizeTargetRequest& a, const FinalizeTargetRequest& b);
inline bool operator!=(const FinalizeTargetRequest& a, const FinalizeTargetRequest& b) { return !(a == b); }
bool Diff(const FinalizeTargetRequest& a, const FinalizeTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FinalizeTargetResponse* out);
bool operator==(const FinalizeTargetResponse& a, const FinalizeTargetResponse& b);
inline bool operator!=(const FinalizeTargetResponse& a, const FinalizeTargetResponse& b) { return !(a == b); }
bool Diff(const FinalizeTargetResponse& a, const FinalizeTargetResponse& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, CreateConfiguredTargetRequest* out);
bool operator==(const CreateConfiguredTargetRequest& a, const CreateConfiguredTargetRequest& b);
inline bool operator!=(const CreateConfiguredTargetRequest& a, const CreateConfiguredTargetRequest& b) { return !(a == b); }
bool Diff(const CreateConfiguredTargetRequest& a, const CreateConfiguredTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UpdateConfiguredTargetRequest* out);
bool operator==(const UpdateConfiguredTargetRequest& a, const UpdateConfiguredTargetRequest& b);
inline bool operator!=(const UpdateConfiguredTargetRequest& a, const UpdateConfiguredTargetRequest& b) { return !(a == b); }
bool Diff(const UpdateConfiguredTargetRequest& a, const UpdateConfiguredTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, MergeConfiguredTargetRequest* out);
bool operator==(const MergeConfiguredTargetRequest& a, const MergeConfiguredTargetRequest& b);
inline bool operator!=(const MergeConfiguredTargetRequest& a, const MergeConfiguredTargetRequest& b) { return !(a == b); }
bool Diff(const MergeConfiguredTargetRequest& a, const MergeConfiguredTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FinalizeConfiguredTargetRequest* out);
bool operator==(const FinalizeConfiguredTargetRequest& a, const FinalizeConfiguredTargetRequest& b);
inline bool operator!=(const FinalizeConfiguredTargetRequest& a, const FinalizeConfiguredTargetRequest& b) { return !(a == b); }
bool Diff(const FinalizeConfiguredTargetRequest& a, const FinalizeConfiguredTargetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, FinalizeConfiguredTargetResponse* out);
bool operator==(const FinalizeConfiguredTargetResponse& a, const FinalizeConfiguredTargetResponse& b);
inline bool operator!=(const FinalizeConfiguredTargetResponse& a, const FinalizeConfiguredTargetResponse& b) { return !(a == b); }
bool Diff(const FinalizeConfiguredTargetResponse& a, const FinalizeConfiguredTargetResponse& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, CreateActionRequest* out);
bool operator==(const CreateActionRequest& a, const CreateActionRequest& b);
inline bool operator!=(const CreateActionRequest& a, const CreateActionRequest& b) { return !(a == b); }
bool Diff(const CreateActionRequest& a, const CreateActionRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UpdateActionRequest* out);
bool operator==(const UpdateActionRequest& a, const UpdateActionRequest& b);
inline bool operator!=(const UpdateActionRequest& a, const UpdateActionRequest& b) { return !(a == b); }
bool Diff(const UpdateActionRequest& a, const UpdateActionRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, MergeActionRequest* out);
bool operator==(const MergeActionRequest& a, const MergeActionRequest& b);
inline bool operator!=(const MergeActionRequest& a, const MergeActionRequest& b) { return !(a == b); }
bool Diff(const MergeActionRequest& a, const MergeActionRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, CreateConfigurationRequest* out);
bool operator==(const CreateConfigurationRequest& a, const CreateConfigurationRequest& b);
inline bool operator!=(const CreateConfigurationRequest& a, const CreateConfigurationRequest& b) { return !(a == b); }
bool Diff(const CreateConfigurationRequest& a, const CreateConfigurationRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UpdateConfigurationRequest* out);
bool operator==(const UpdateConfigurationRequest& a, const UpdateConfigurationRequest& b);
inline bool operator!=(const UpdateConfigurationRequest& a, const UpdateConfigurationRequest& b) { return !(a == b); }
bool Diff(const UpdateConfigurationRequest& a, const UpdateConfigurationRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, CreateFileSetRequest* out);
bool operator==(const CreateFileSetRequest& a, const CreateFileSetRequest& b);
inline bool operator!=(const CreateFileSetRequest& a, const CreateFileSetRequest& b) { return !(a == b); }
bool Diff(const CreateFileSetRequest& a, const CreateFileSetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UpdateFileSetRequest* out);
bool operator==(const UpdateFileSetRequest& a, const UpdateFileSetRequest& b);
inline bool operator!=(const UpdateFileSetRequest& a, const UpdateFileSetRequest& b) { return !(a == b); }
bool Diff(const UpdateFileSetRequest& a, const UpdateFileSetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, MergeFileSetRequest* out);
bool operator==(const MergeFileSetRequest& a, const MergeFileSetRequest& b);
inline bool operator!=(const MergeFileSetRequest& a, const MergeFileSetRequest& b) { return !(a == b); }
bool Diff(const MergeFileSetRequest& a, const MergeFileSetRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UploadBatchRequest* out);
bool operator==(const UploadBatchRequest& a, const UploadBatchRequest& b);
inline bool operator!=(const UploadBatchRequest& a, const UploadBatchRequest& b) { return !(a == b); }
bool Diff(const UploadBatchRequest& a, const UploadBatchRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UploadBatchResponse* out);
bool operator==(const UploadBatchResponse& a, const UploadBatchResponse& b);
inline bool operator!=(const UploadBatchResponse& a, const UploadBatchResponse& b) { return !(a == b); }
bool Diff(const UploadBatchResponse& a, const UploadBatchResponse& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, UploadRequest* out);
bool operator==(const UploadRequest& a, const UploadRequest& b);
inline bool operator!=(const UploadRequest& a, const UploadRequest& b) { return !(a == b); }
bool Diff(const UploadRequest& a, const UploadRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

bool Diff(UploadRequest::UploadOperation a, UploadRequest::UploadOperation b, std::vector<std::string>* diffs, const std::string& prefix);
bool ParseFromStream(InputStream& input, UploadRequest::Id* out);
bool operator==(const UploadRequest::Id& a, const UploadRequest::Id& b);
inline bool operator!=(const UploadRequest::Id& a, const UploadRequest::Id& b) { return !(a == b); }
bool Diff(const UploadRequest::Id& a, const UploadRequest::Id& b, std::vector<std::string>* diffs, const std::string& prefix);

bool ParseFromStream(InputStream& input, GetInvocationUploadMetadataRequest* out);
bool operator==(const GetInvocationUploadMetadataRequest& a, const GetInvocationUploadMetadataRequest& b);
inline bool operator!=(const GetInvocationUploadMetadataRequest& a, const GetInvocationUploadMetadataRequest& b) { return !(a == b); }
bool Diff(const GetInvocationUploadMetadataRequest& a, const GetInvocationUploadMetadataRequest& b, std::vector<std::string>* diffs, const std::string& prefix);

}  // namespace v2
}  // namespace resultstore
}  // namespace devtools
}  // namespace google
}  // namespace rs
#endif  // NINJA_RESULTSTORE_READER_PB_H