proxy_wasm_intrinsics_lite.pb.h

// Copyright 2016-2019 Envoy Project Authors
// Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: proxy_wasm_intrinsics_lite.proto
// Protobuf C++ Version: 5.26.1

#ifndef GOOGLE_PROTOBUF_INCLUDED_proxy_5fwasm_5fintrinsics_5flite_2eproto_2epb_2eh
#define GOOGLE_PROTOBUF_INCLUDED_proxy_5fwasm_5fintrinsics_5flite_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

#include "google/protobuf/port_def.inc"
#if PROTOBUF_VERSION != 5026001
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/port_undef.inc"
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "struct_lite.pb.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_proxy_5fwasm_5fintrinsics_5flite_2eproto

namespace google {
namespace protobuf {
namespace internal {
class AnyMetadata;
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto {
  static const ::uint32_t offsets[];
};
class Any;
struct AnyDefaultTypeInternal;
extern AnyDefaultTypeInternal _Any_default_instance_;
class DataSource;
struct DataSourceDefaultTypeInternal;
extern DataSourceDefaultTypeInternal _DataSource_default_instance_;
class GrpcService;
struct GrpcServiceDefaultTypeInternal;
extern GrpcServiceDefaultTypeInternal _GrpcService_default_instance_;
class GrpcService_EnvoyGrpc;
struct GrpcService_EnvoyGrpcDefaultTypeInternal;
extern GrpcService_EnvoyGrpcDefaultTypeInternal _GrpcService_EnvoyGrpc_default_instance_;
class GrpcService_GoogleGrpc;
struct GrpcService_GoogleGrpcDefaultTypeInternal;
extern GrpcService_GoogleGrpcDefaultTypeInternal _GrpcService_GoogleGrpc_default_instance_;
class GrpcService_GoogleGrpc_CallCredentials;
struct GrpcService_GoogleGrpc_CallCredentialsDefaultTypeInternal;
extern GrpcService_GoogleGrpc_CallCredentialsDefaultTypeInternal _GrpcService_GoogleGrpc_CallCredentials_default_instance_;
class GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials;
struct GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentialsDefaultTypeInternal;
extern GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentialsDefaultTypeInternal _GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials_default_instance_;
class GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin;
struct GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPluginDefaultTypeInternal;
extern GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPluginDefaultTypeInternal _GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_default_instance_;
class GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials;
struct GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentialsDefaultTypeInternal;
extern GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentialsDefaultTypeInternal _GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials_default_instance_;
class GrpcService_GoogleGrpc_CallCredentials_StsService;
struct GrpcService_GoogleGrpc_CallCredentials_StsServiceDefaultTypeInternal;
extern GrpcService_GoogleGrpc_CallCredentials_StsServiceDefaultTypeInternal _GrpcService_GoogleGrpc_CallCredentials_StsService_default_instance_;
class GrpcService_GoogleGrpc_ChannelCredentials;
struct GrpcService_GoogleGrpc_ChannelCredentialsDefaultTypeInternal;
extern GrpcService_GoogleGrpc_ChannelCredentialsDefaultTypeInternal _GrpcService_GoogleGrpc_ChannelCredentials_default_instance_;
class GrpcService_GoogleGrpc_Empty;
struct GrpcService_GoogleGrpc_EmptyDefaultTypeInternal;
extern GrpcService_GoogleGrpc_EmptyDefaultTypeInternal _GrpcService_GoogleGrpc_Empty_default_instance_;
class GrpcService_GoogleGrpc_GoogleLocalCredentials;
struct GrpcService_GoogleGrpc_GoogleLocalCredentialsDefaultTypeInternal;
extern GrpcService_GoogleGrpc_GoogleLocalCredentialsDefaultTypeInternal _GrpcService_GoogleGrpc_GoogleLocalCredentials_default_instance_;
class GrpcService_GoogleGrpc_SslCredentials;
struct GrpcService_GoogleGrpc_SslCredentialsDefaultTypeInternal;
extern GrpcService_GoogleGrpc_SslCredentialsDefaultTypeInternal _GrpcService_GoogleGrpc_SslCredentials_default_instance_;
class GrpcService_HeaderValue;
struct GrpcService_HeaderValueDefaultTypeInternal;
extern GrpcService_HeaderValueDefaultTypeInternal _GrpcService_HeaderValue_default_instance_;
class WKT;
struct WKTDefaultTypeInternal;
extern WKTDefaultTypeInternal _WKT_default_instance_;
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google


// ===================================================================


// -------------------------------------------------------------------

class GrpcService_HeaderValue final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.HeaderValue) */ {
 public:
  inline GrpcService_HeaderValue() : GrpcService_HeaderValue(nullptr) {}
  ~GrpcService_HeaderValue() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_HeaderValue(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_HeaderValue(const GrpcService_HeaderValue& from) : GrpcService_HeaderValue(nullptr, from) {}
  inline GrpcService_HeaderValue(GrpcService_HeaderValue&& from) noexcept
      : GrpcService_HeaderValue(nullptr, std::move(from)) {}
  inline GrpcService_HeaderValue& operator=(const GrpcService_HeaderValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_HeaderValue& operator=(GrpcService_HeaderValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_HeaderValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrpcService_HeaderValue* internal_default_instance() {
    return reinterpret_cast<const GrpcService_HeaderValue*>(
        &_GrpcService_HeaderValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 14;
  friend void swap(GrpcService_HeaderValue& a, GrpcService_HeaderValue& b) { a.Swap(&b); }
  inline void Swap(GrpcService_HeaderValue* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_HeaderValue* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_HeaderValue* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_HeaderValue>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_HeaderValue& from);
  void MergeFrom(const GrpcService_HeaderValue& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_HeaderValue* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.HeaderValue"; }

 protected:
  explicit GrpcService_HeaderValue(::google::protobuf::Arena* arena);
  GrpcService_HeaderValue(::google::protobuf::Arena* arena, const GrpcService_HeaderValue& from);
  GrpcService_HeaderValue(::google::protobuf::Arena* arena, GrpcService_HeaderValue&& from) noexcept
      : GrpcService_HeaderValue(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key() ;
  const std::string& key() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_key(Arg_&& arg, Args_... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* value);

  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
      const std::string& value);
  std::string* _internal_mutable_key();

  public:
  // string value = 2;
  void clear_value() ;
  const std::string& value() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_value(Arg_&& arg, Args_... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);

  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(
      const std::string& value);
  std::string* _internal_mutable_value();

  public:
  // @@protoc_insertion_point(class_scope:GrpcService.HeaderValue)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      40, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr key_;
    ::google::protobuf::internal::ArenaStringPtr value_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc_GoogleLocalCredentials final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc.GoogleLocalCredentials) */ {
 public:
  inline GrpcService_GoogleGrpc_GoogleLocalCredentials() : GrpcService_GoogleGrpc_GoogleLocalCredentials(nullptr) {}
  ~GrpcService_GoogleGrpc_GoogleLocalCredentials() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc_GoogleLocalCredentials(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc_GoogleLocalCredentials(const GrpcService_GoogleGrpc_GoogleLocalCredentials& from) : GrpcService_GoogleGrpc_GoogleLocalCredentials(nullptr, from) {}
  inline GrpcService_GoogleGrpc_GoogleLocalCredentials(GrpcService_GoogleGrpc_GoogleLocalCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_GoogleLocalCredentials(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc_GoogleLocalCredentials& operator=(const GrpcService_GoogleGrpc_GoogleLocalCredentials& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc_GoogleLocalCredentials& operator=(GrpcService_GoogleGrpc_GoogleLocalCredentials&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc_GoogleLocalCredentials& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrpcService_GoogleGrpc_GoogleLocalCredentials* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc_GoogleLocalCredentials*>(
        &_GrpcService_GoogleGrpc_GoogleLocalCredentials_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(GrpcService_GoogleGrpc_GoogleLocalCredentials& a, GrpcService_GoogleGrpc_GoogleLocalCredentials& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc_GoogleLocalCredentials* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc_GoogleLocalCredentials* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc_GoogleLocalCredentials* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc_GoogleLocalCredentials>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc_GoogleLocalCredentials& from);
  void MergeFrom(const GrpcService_GoogleGrpc_GoogleLocalCredentials& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc_GoogleLocalCredentials* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc.GoogleLocalCredentials"; }

 protected:
  explicit GrpcService_GoogleGrpc_GoogleLocalCredentials(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc_GoogleLocalCredentials(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc_GoogleLocalCredentials& from);
  GrpcService_GoogleGrpc_GoogleLocalCredentials(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc_GoogleLocalCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_GoogleLocalCredentials(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc.GoogleLocalCredentials)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 0, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc_Empty final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc.Empty) */ {
 public:
  inline GrpcService_GoogleGrpc_Empty() : GrpcService_GoogleGrpc_Empty(nullptr) {}
  ~GrpcService_GoogleGrpc_Empty() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc_Empty(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc_Empty(const GrpcService_GoogleGrpc_Empty& from) : GrpcService_GoogleGrpc_Empty(nullptr, from) {}
  inline GrpcService_GoogleGrpc_Empty(GrpcService_GoogleGrpc_Empty&& from) noexcept
      : GrpcService_GoogleGrpc_Empty(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc_Empty& operator=(const GrpcService_GoogleGrpc_Empty& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc_Empty& operator=(GrpcService_GoogleGrpc_Empty&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc_Empty& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrpcService_GoogleGrpc_Empty* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc_Empty*>(
        &_GrpcService_GoogleGrpc_Empty_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(GrpcService_GoogleGrpc_Empty& a, GrpcService_GoogleGrpc_Empty& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc_Empty* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc_Empty* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc_Empty* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc_Empty>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc_Empty& from);
  void MergeFrom(const GrpcService_GoogleGrpc_Empty& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc_Empty* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc.Empty"; }

 protected:
  explicit GrpcService_GoogleGrpc_Empty(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc_Empty(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc_Empty& from);
  GrpcService_GoogleGrpc_Empty(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc_Empty&& from) noexcept
      : GrpcService_GoogleGrpc_Empty(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc.Empty)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 0, 0,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc_CallCredentials_StsService final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc.CallCredentials.StsService) */ {
 public:
  inline GrpcService_GoogleGrpc_CallCredentials_StsService() : GrpcService_GoogleGrpc_CallCredentials_StsService(nullptr) {}
  ~GrpcService_GoogleGrpc_CallCredentials_StsService() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc_CallCredentials_StsService(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc_CallCredentials_StsService(const GrpcService_GoogleGrpc_CallCredentials_StsService& from) : GrpcService_GoogleGrpc_CallCredentials_StsService(nullptr, from) {}
  inline GrpcService_GoogleGrpc_CallCredentials_StsService(GrpcService_GoogleGrpc_CallCredentials_StsService&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials_StsService(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc_CallCredentials_StsService& operator=(const GrpcService_GoogleGrpc_CallCredentials_StsService& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc_CallCredentials_StsService& operator=(GrpcService_GoogleGrpc_CallCredentials_StsService&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc_CallCredentials_StsService& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrpcService_GoogleGrpc_CallCredentials_StsService* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc_CallCredentials_StsService*>(
        &_GrpcService_GoogleGrpc_CallCredentials_StsService_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 11;
  friend void swap(GrpcService_GoogleGrpc_CallCredentials_StsService& a, GrpcService_GoogleGrpc_CallCredentials_StsService& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc_CallCredentials_StsService* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc_CallCredentials_StsService* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc_CallCredentials_StsService* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc_CallCredentials_StsService>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc_CallCredentials_StsService& from);
  void MergeFrom(const GrpcService_GoogleGrpc_CallCredentials_StsService& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc_CallCredentials_StsService* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc.CallCredentials.StsService"; }

 protected:
  explicit GrpcService_GoogleGrpc_CallCredentials_StsService(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc_CallCredentials_StsService(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc_CallCredentials_StsService& from);
  GrpcService_GoogleGrpc_CallCredentials_StsService(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc_CallCredentials_StsService&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials_StsService(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kTokenExchangeServiceUriFieldNumber = 1,
    kResourceFieldNumber = 2,
    kAudienceFieldNumber = 3,
    kScopeFieldNumber = 4,
    kRequestedTokenTypeFieldNumber = 5,
    kSubjectTokenPathFieldNumber = 6,
    kSubjectTokenTypeFieldNumber = 7,
    kActorTokenPathFieldNumber = 8,
    kActorTokenTypeFieldNumber = 9,
  };
  // string token_exchange_service_uri = 1;
  void clear_token_exchange_service_uri() ;
  const std::string& token_exchange_service_uri() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_token_exchange_service_uri(Arg_&& arg, Args_... args);
  std::string* mutable_token_exchange_service_uri();
  PROTOBUF_NODISCARD std::string* release_token_exchange_service_uri();
  void set_allocated_token_exchange_service_uri(std::string* value);

  private:
  const std::string& _internal_token_exchange_service_uri() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token_exchange_service_uri(
      const std::string& value);
  std::string* _internal_mutable_token_exchange_service_uri();

  public:
  // string resource = 2;
  void clear_resource() ;
  const std::string& resource() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_resource(Arg_&& arg, Args_... args);
  std::string* mutable_resource();
  PROTOBUF_NODISCARD std::string* release_resource();
  void set_allocated_resource(std::string* value);

  private:
  const std::string& _internal_resource() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_resource(
      const std::string& value);
  std::string* _internal_mutable_resource();

  public:
  // string audience = 3;
  void clear_audience() ;
  const std::string& audience() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_audience(Arg_&& arg, Args_... args);
  std::string* mutable_audience();
  PROTOBUF_NODISCARD std::string* release_audience();
  void set_allocated_audience(std::string* value);

  private:
  const std::string& _internal_audience() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_audience(
      const std::string& value);
  std::string* _internal_mutable_audience();

  public:
  // string scope = 4;
  void clear_scope() ;
  const std::string& scope() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_scope(Arg_&& arg, Args_... args);
  std::string* mutable_scope();
  PROTOBUF_NODISCARD std::string* release_scope();
  void set_allocated_scope(std::string* value);

  private:
  const std::string& _internal_scope() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_scope(
      const std::string& value);
  std::string* _internal_mutable_scope();

  public:
  // string requested_token_type = 5;
  void clear_requested_token_type() ;
  const std::string& requested_token_type() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_requested_token_type(Arg_&& arg, Args_... args);
  std::string* mutable_requested_token_type();
  PROTOBUF_NODISCARD std::string* release_requested_token_type();
  void set_allocated_requested_token_type(std::string* value);

  private:
  const std::string& _internal_requested_token_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_requested_token_type(
      const std::string& value);
  std::string* _internal_mutable_requested_token_type();

  public:
  // string subject_token_path = 6;
  void clear_subject_token_path() ;
  const std::string& subject_token_path() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subject_token_path(Arg_&& arg, Args_... args);
  std::string* mutable_subject_token_path();
  PROTOBUF_NODISCARD std::string* release_subject_token_path();
  void set_allocated_subject_token_path(std::string* value);

  private:
  const std::string& _internal_subject_token_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subject_token_path(
      const std::string& value);
  std::string* _internal_mutable_subject_token_path();

  public:
  // string subject_token_type = 7;
  void clear_subject_token_type() ;
  const std::string& subject_token_type() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_subject_token_type(Arg_&& arg, Args_... args);
  std::string* mutable_subject_token_type();
  PROTOBUF_NODISCARD std::string* release_subject_token_type();
  void set_allocated_subject_token_type(std::string* value);

  private:
  const std::string& _internal_subject_token_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subject_token_type(
      const std::string& value);
  std::string* _internal_mutable_subject_token_type();

  public:
  // string actor_token_path = 8;
  void clear_actor_token_path() ;
  const std::string& actor_token_path() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_actor_token_path(Arg_&& arg, Args_... args);
  std::string* mutable_actor_token_path();
  PROTOBUF_NODISCARD std::string* release_actor_token_path();
  void set_allocated_actor_token_path(std::string* value);

  private:
  const std::string& _internal_actor_token_path() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_actor_token_path(
      const std::string& value);
  std::string* _internal_mutable_actor_token_path();

  public:
  // string actor_token_type = 9;
  void clear_actor_token_type() ;
  const std::string& actor_token_type() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_actor_token_type(Arg_&& arg, Args_... args);
  std::string* mutable_actor_token_type();
  PROTOBUF_NODISCARD std::string* release_actor_token_type();
  void set_allocated_actor_token_type(std::string* value);

  private:
  const std::string& _internal_actor_token_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_actor_token_type(
      const std::string& value);
  std::string* _internal_mutable_actor_token_type();

  public:
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc.CallCredentials.StsService)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      4, 9, 0,
      201, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr token_exchange_service_uri_;
    ::google::protobuf::internal::ArenaStringPtr resource_;
    ::google::protobuf::internal::ArenaStringPtr audience_;
    ::google::protobuf::internal::ArenaStringPtr scope_;
    ::google::protobuf::internal::ArenaStringPtr requested_token_type_;
    ::google::protobuf::internal::ArenaStringPtr subject_token_path_;
    ::google::protobuf::internal::ArenaStringPtr subject_token_type_;
    ::google::protobuf::internal::ArenaStringPtr actor_token_path_;
    ::google::protobuf::internal::ArenaStringPtr actor_token_type_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials) */ {
 public:
  inline GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials() : GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(nullptr) {}
  ~GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(const GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& from) : GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(nullptr, from) {}
  inline GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& operator=(const GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& operator=(GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials*>(
        &_GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 8;
  friend void swap(GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& a, GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& from);
  void MergeFrom(const GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials"; }

 protected:
  explicit GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& from);
  GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kJsonKeyFieldNumber = 1,
    kTokenLifetimeSecondsFieldNumber = 2,
  };
  // string json_key = 1;
  void clear_json_key() ;
  const std::string& json_key() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_json_key(Arg_&& arg, Args_... args);
  std::string* mutable_json_key();
  PROTOBUF_NODISCARD std::string* release_json_key();
  void set_allocated_json_key(std::string* value);

  private:
  const std::string& _internal_json_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_json_key(
      const std::string& value);
  std::string* _internal_mutable_json_key();

  public:
  // uint64 token_lifetime_seconds = 2;
  void clear_token_lifetime_seconds() ;
  ::uint64_t token_lifetime_seconds() const;
  void set_token_lifetime_seconds(::uint64_t value);

  private:
  ::uint64_t _internal_token_lifetime_seconds() const;
  void _internal_set_token_lifetime_seconds(::uint64_t value);

  public:
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      90, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr json_key_;
    ::uint64_t token_lifetime_seconds_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials) */ {
 public:
  inline GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials() : GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(nullptr) {}
  ~GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(const GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& from) : GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(nullptr, from) {}
  inline GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& operator=(const GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& operator=(GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials*>(
        &_GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 9;
  friend void swap(GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& a, GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& from);
  void MergeFrom(const GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials"; }

 protected:
  explicit GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& from);
  GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kAuthorizationTokenFieldNumber = 1,
    kAuthoritySelectorFieldNumber = 2,
  };
  // string authorization_token = 1;
  void clear_authorization_token() ;
  const std::string& authorization_token() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_authorization_token(Arg_&& arg, Args_... args);
  std::string* mutable_authorization_token();
  PROTOBUF_NODISCARD std::string* release_authorization_token();
  void set_allocated_authorization_token(std::string* value);

  private:
  const std::string& _internal_authorization_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_authorization_token(
      const std::string& value);
  std::string* _internal_mutable_authorization_token();

  public:
  // string authority_selector = 2;
  void clear_authority_selector() ;
  const std::string& authority_selector() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_authority_selector(Arg_&& arg, Args_... args);
  std::string* mutable_authority_selector();
  PROTOBUF_NODISCARD std::string* release_authority_selector();
  void set_allocated_authority_selector(std::string* value);

  private:
  const std::string& _internal_authority_selector() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_authority_selector(
      const std::string& value);
  std::string* _internal_mutable_authority_selector();

  public:
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      105, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr authorization_token_;
    ::google::protobuf::internal::ArenaStringPtr authority_selector_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_EnvoyGrpc final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.EnvoyGrpc) */ {
 public:
  inline GrpcService_EnvoyGrpc() : GrpcService_EnvoyGrpc(nullptr) {}
  ~GrpcService_EnvoyGrpc() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_EnvoyGrpc(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_EnvoyGrpc(const GrpcService_EnvoyGrpc& from) : GrpcService_EnvoyGrpc(nullptr, from) {}
  inline GrpcService_EnvoyGrpc(GrpcService_EnvoyGrpc&& from) noexcept
      : GrpcService_EnvoyGrpc(nullptr, std::move(from)) {}
  inline GrpcService_EnvoyGrpc& operator=(const GrpcService_EnvoyGrpc& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_EnvoyGrpc& operator=(GrpcService_EnvoyGrpc&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_EnvoyGrpc& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrpcService_EnvoyGrpc* internal_default_instance() {
    return reinterpret_cast<const GrpcService_EnvoyGrpc*>(
        &_GrpcService_EnvoyGrpc_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(GrpcService_EnvoyGrpc& a, GrpcService_EnvoyGrpc& b) { a.Swap(&b); }
  inline void Swap(GrpcService_EnvoyGrpc* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_EnvoyGrpc* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_EnvoyGrpc* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_EnvoyGrpc>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_EnvoyGrpc& from);
  void MergeFrom(const GrpcService_EnvoyGrpc& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_EnvoyGrpc* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.EnvoyGrpc"; }

 protected:
  explicit GrpcService_EnvoyGrpc(::google::protobuf::Arena* arena);
  GrpcService_EnvoyGrpc(::google::protobuf::Arena* arena, const GrpcService_EnvoyGrpc& from);
  GrpcService_EnvoyGrpc(::google::protobuf::Arena* arena, GrpcService_EnvoyGrpc&& from) noexcept
      : GrpcService_EnvoyGrpc(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kClusterNameFieldNumber = 1,
  };
  // string cluster_name = 1;
  void clear_cluster_name() ;
  const std::string& cluster_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_cluster_name(Arg_&& arg, Args_... args);
  std::string* mutable_cluster_name();
  PROTOBUF_NODISCARD std::string* release_cluster_name();
  void set_allocated_cluster_name(std::string* value);

  private:
  const std::string& _internal_cluster_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cluster_name(
      const std::string& value);
  std::string* _internal_mutable_cluster_name();

  public:
  // @@protoc_insertion_point(class_scope:GrpcService.EnvoyGrpc)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 0,
      42, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr cluster_name_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class DataSource final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:DataSource) */ {
 public:
  inline DataSource() : DataSource(nullptr) {}
  ~DataSource() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR DataSource(
      ::google::protobuf::internal::ConstantInitialized);

  inline DataSource(const DataSource& from) : DataSource(nullptr, from) {}
  inline DataSource(DataSource&& from) noexcept
      : DataSource(nullptr, std::move(from)) {}
  inline DataSource& operator=(const DataSource& from) {
    CopyFrom(from);
    return *this;
  }
  inline DataSource& operator=(DataSource&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DataSource& default_instance() {
    return *internal_default_instance();
  }
  enum SpecifierCase {
    kFilename = 1,
    kInlineBytes = 2,
    kInlineString = 3,
    SPECIFIER_NOT_SET = 0,
  };
  static inline const DataSource* internal_default_instance() {
    return reinterpret_cast<const DataSource*>(
        &_DataSource_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(DataSource& a, DataSource& b) { a.Swap(&b); }
  inline void Swap(DataSource* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DataSource* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DataSource* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<DataSource>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const DataSource& from);
  void MergeFrom(const DataSource& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(DataSource* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "DataSource"; }

 protected:
  explicit DataSource(::google::protobuf::Arena* arena);
  DataSource(::google::protobuf::Arena* arena, const DataSource& from);
  DataSource(::google::protobuf::Arena* arena, DataSource&& from) noexcept
      : DataSource(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kFilenameFieldNumber = 1,
    kInlineBytesFieldNumber = 2,
    kInlineStringFieldNumber = 3,
  };
  // string filename = 1;
  bool has_filename() const;
  void clear_filename() ;
  const std::string& filename() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_filename(Arg_&& arg, Args_... args);
  std::string* mutable_filename();
  PROTOBUF_NODISCARD std::string* release_filename();
  void set_allocated_filename(std::string* value);

  private:
  const std::string& _internal_filename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(
      const std::string& value);
  std::string* _internal_mutable_filename();

  public:
  // bytes inline_bytes = 2;
  bool has_inline_bytes() const;
  void clear_inline_bytes() ;
  const std::string& inline_bytes() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_inline_bytes(Arg_&& arg, Args_... args);
  std::string* mutable_inline_bytes();
  PROTOBUF_NODISCARD std::string* release_inline_bytes();
  void set_allocated_inline_bytes(std::string* value);

  private:
  const std::string& _internal_inline_bytes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_inline_bytes(
      const std::string& value);
  std::string* _internal_mutable_inline_bytes();

  public:
  // string inline_string = 3;
  bool has_inline_string() const;
  void clear_inline_string() ;
  const std::string& inline_string() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_inline_string(Arg_&& arg, Args_... args);
  std::string* mutable_inline_string();
  PROTOBUF_NODISCARD std::string* release_inline_string();
  void set_allocated_inline_string(std::string* value);

  private:
  const std::string& _internal_inline_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_inline_string(
      const std::string& value);
  std::string* _internal_mutable_inline_string();

  public:
  void clear_specifier();
  SpecifierCase specifier_case() const;
  // @@protoc_insertion_point(class_scope:DataSource)
 private:
  class _Internal;
  void set_has_filename();
  void set_has_inline_bytes();
  void set_has_inline_string();
  inline bool has_specifier() const;
  inline void clear_has_specifier();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 3, 0,
      40, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    union SpecifierUnion {
      constexpr SpecifierUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr filename_;
      ::google::protobuf::internal::ArenaStringPtr inline_bytes_;
      ::google::protobuf::internal::ArenaStringPtr inline_string_;
    } specifier_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class Any final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:Any) */ {
 public:
  inline Any() : Any(nullptr) {}
  ~Any() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR Any(
      ::google::protobuf::internal::ConstantInitialized);

  inline Any(const Any& from) : Any(nullptr, from) {}
  inline Any(Any&& from) noexcept
      : Any(nullptr, std::move(from)) {}
  inline Any& operator=(const Any& from) {
    CopyFrom(from);
    return *this;
  }
  inline Any& operator=(Any&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const Any& default_instance() {
    return *internal_default_instance();
  }
  static inline const Any* internal_default_instance() {
    return reinterpret_cast<const Any*>(
        &_Any_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(Any& a, Any& b) { a.Swap(&b); }
  inline void Swap(Any* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Any* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Any* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<Any>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const Any& from);
  void MergeFrom(const Any& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(Any* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "Any"; }

 protected:
  explicit Any(::google::protobuf::Arena* arena);
  Any(::google::protobuf::Arena* arena, const Any& from);
  Any(::google::protobuf::Arena* arena, Any&& from) noexcept
      : Any(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kTypeUrlFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string type_url = 1;
  void clear_type_url() ;
  const std::string& type_url() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_type_url(Arg_&& arg, Args_... args);
  std::string* mutable_type_url();
  PROTOBUF_NODISCARD std::string* release_type_url();
  void set_allocated_type_url(std::string* value);

  private:
  const std::string& _internal_type_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_url(
      const std::string& value);
  std::string* _internal_mutable_type_url();

  public:
  // bytes value = 2;
  void clear_value() ;
  const std::string& value() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_value(Arg_&& arg, Args_... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);

  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(
      const std::string& value);
  std::string* _internal_mutable_value();

  public:
  // @@protoc_insertion_point(class_scope:Any)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      1, 2, 0,
      20, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr type_url_;
    ::google::protobuf::internal::ArenaStringPtr value_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class WKT final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:WKT) */ {
 public:
  inline WKT() : WKT(nullptr) {}
  ~WKT() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR WKT(
      ::google::protobuf::internal::ConstantInitialized);

  inline WKT(const WKT& from) : WKT(nullptr, from) {}
  inline WKT(WKT&& from) noexcept
      : WKT(nullptr, std::move(from)) {}
  inline WKT& operator=(const WKT& from) {
    CopyFrom(from);
    return *this;
  }
  inline WKT& operator=(WKT&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const WKT& default_instance() {
    return *internal_default_instance();
  }
  static inline const WKT* internal_default_instance() {
    return reinterpret_cast<const WKT*>(
        &_WKT_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(WKT& a, WKT& b) { a.Swap(&b); }
  inline void Swap(WKT* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(WKT* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WKT* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<WKT>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const WKT& from);
  void MergeFrom(const WKT& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(WKT* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "WKT"; }

 protected:
  explicit WKT(::google::protobuf::Arena* arena);
  WKT(::google::protobuf::Arena* arena, const WKT& from);
  WKT(::google::protobuf::Arena* arena, WKT&& from) noexcept
      : WKT(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kStructFieldNumber = 1,
  };
  // .google.protobuf.Struct struct = 1;
  bool has_struct_() const;
  void clear_struct_() ;
  const ::google::protobuf::Struct& struct_() const;
  PROTOBUF_NODISCARD ::google::protobuf::Struct* release_struct_();
  ::google::protobuf::Struct* mutable_struct_();
  void set_allocated_struct_(::google::protobuf::Struct* value);
  void unsafe_arena_set_allocated_struct_(::google::protobuf::Struct* value);
  ::google::protobuf::Struct* unsafe_arena_release_struct_();

  private:
  const ::google::protobuf::Struct& _internal_struct_() const;
  ::google::protobuf::Struct* _internal_mutable_struct_();

  public:
  // @@protoc_insertion_point(class_scope:WKT)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 1, 1,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::Struct* struct__;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc_SslCredentials final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc.SslCredentials) */ {
 public:
  inline GrpcService_GoogleGrpc_SslCredentials() : GrpcService_GoogleGrpc_SslCredentials(nullptr) {}
  ~GrpcService_GoogleGrpc_SslCredentials() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc_SslCredentials(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc_SslCredentials(const GrpcService_GoogleGrpc_SslCredentials& from) : GrpcService_GoogleGrpc_SslCredentials(nullptr, from) {}
  inline GrpcService_GoogleGrpc_SslCredentials(GrpcService_GoogleGrpc_SslCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_SslCredentials(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc_SslCredentials& operator=(const GrpcService_GoogleGrpc_SslCredentials& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc_SslCredentials& operator=(GrpcService_GoogleGrpc_SslCredentials&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc_SslCredentials& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrpcService_GoogleGrpc_SslCredentials* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc_SslCredentials*>(
        &_GrpcService_GoogleGrpc_SslCredentials_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(GrpcService_GoogleGrpc_SslCredentials& a, GrpcService_GoogleGrpc_SslCredentials& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc_SslCredentials* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc_SslCredentials* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc_SslCredentials* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc_SslCredentials>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc_SslCredentials& from);
  void MergeFrom(const GrpcService_GoogleGrpc_SslCredentials& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc_SslCredentials* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc.SslCredentials"; }

 protected:
  explicit GrpcService_GoogleGrpc_SslCredentials(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc_SslCredentials(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc_SslCredentials& from);
  GrpcService_GoogleGrpc_SslCredentials(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc_SslCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_SslCredentials(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kRootCertsFieldNumber = 1,
    kPrivateKeyFieldNumber = 2,
    kCertChainFieldNumber = 3,
  };
  // .DataSource root_certs = 1;
  bool has_root_certs() const;
  void clear_root_certs() ;
  const ::DataSource& root_certs() const;
  PROTOBUF_NODISCARD ::DataSource* release_root_certs();
  ::DataSource* mutable_root_certs();
  void set_allocated_root_certs(::DataSource* value);
  void unsafe_arena_set_allocated_root_certs(::DataSource* value);
  ::DataSource* unsafe_arena_release_root_certs();

  private:
  const ::DataSource& _internal_root_certs() const;
  ::DataSource* _internal_mutable_root_certs();

  public:
  // .DataSource private_key = 2;
  bool has_private_key() const;
  void clear_private_key() ;
  const ::DataSource& private_key() const;
  PROTOBUF_NODISCARD ::DataSource* release_private_key();
  ::DataSource* mutable_private_key();
  void set_allocated_private_key(::DataSource* value);
  void unsafe_arena_set_allocated_private_key(::DataSource* value);
  ::DataSource* unsafe_arena_release_private_key();

  private:
  const ::DataSource& _internal_private_key() const;
  ::DataSource* _internal_mutable_private_key();

  public:
  // .DataSource cert_chain = 3;
  bool has_cert_chain() const;
  void clear_cert_chain() ;
  const ::DataSource& cert_chain() const;
  PROTOBUF_NODISCARD ::DataSource* release_cert_chain();
  ::DataSource* mutable_cert_chain();
  void set_allocated_cert_chain(::DataSource* value);
  void unsafe_arena_set_allocated_cert_chain(::DataSource* value);
  ::DataSource* unsafe_arena_release_cert_chain();

  private:
  const ::DataSource& _internal_cert_chain() const;
  ::DataSource* _internal_mutable_cert_chain();

  public:
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc.SslCredentials)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      2, 3, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::DataSource* root_certs_;
    ::DataSource* private_key_;
    ::DataSource* cert_chain_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin) */ {
 public:
  inline GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin() : GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(nullptr) {}
  ~GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(const GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& from) : GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(nullptr, from) {}
  inline GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& operator=(const GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& operator=(GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& default_instance() {
    return *internal_default_instance();
  }
  enum ConfigTypeCase {
    kConfig = 2,
    kTypedConfig = 3,
    CONFIG_TYPE_NOT_SET = 0,
  };
  static inline const GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin*>(
        &_GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 10;
  friend void swap(GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& a, GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& from);
  void MergeFrom(const GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin"; }

 protected:
  explicit GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& from);
  GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNameFieldNumber = 1,
    kConfigFieldNumber = 2,
    kTypedConfigFieldNumber = 3,
  };
  // string name = 1;
  void clear_name() ;
  const std::string& name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* value);

  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(
      const std::string& value);
  std::string* _internal_mutable_name();

  public:
  // .google.protobuf.Struct config = 2 [deprecated = true];
  [[deprecated]]  bool has_config() const;
  private:
  bool _internal_has_config() const;

  public:
  [[deprecated]]  void clear_config() ;
  [[deprecated]] const ::google::protobuf::Struct& config() const;
  [[deprecated]] PROTOBUF_NODISCARD ::google::protobuf::Struct* release_config();
  [[deprecated]] ::google::protobuf::Struct* mutable_config();
  [[deprecated]] void set_allocated_config(::google::protobuf::Struct* value);
  [[deprecated]] void unsafe_arena_set_allocated_config(::google::protobuf::Struct* value);
  [[deprecated]] ::google::protobuf::Struct* unsafe_arena_release_config();

  private:
  const ::google::protobuf::Struct& _internal_config() const;
  ::google::protobuf::Struct* _internal_mutable_config();

  public:
  // .Any typed_config = 3;
  bool has_typed_config() const;
  private:
  bool _internal_has_typed_config() const;

  public:
  void clear_typed_config() ;
  const ::Any& typed_config() const;
  PROTOBUF_NODISCARD ::Any* release_typed_config();
  ::Any* mutable_typed_config();
  void set_allocated_typed_config(::Any* value);
  void unsafe_arena_set_allocated_typed_config(::Any* value);
  ::Any* unsafe_arena_release_typed_config();

  private:
  const ::Any& _internal_typed_config() const;
  ::Any* _internal_mutable_typed_config();

  public:
  void clear_config_type();
  ConfigTypeCase config_type_case() const;
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin)
 private:
  class _Internal;
  void set_has_config();
  void set_has_typed_config();
  inline bool has_config_type() const;
  inline void clear_has_config_type();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 3, 2,
      81, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::ArenaStringPtr name_;
    union ConfigTypeUnion {
      constexpr ConfigTypeUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::Struct* config_;
      ::Any* typed_config_;
    } config_type_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc_ChannelCredentials final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc.ChannelCredentials) */ {
 public:
  inline GrpcService_GoogleGrpc_ChannelCredentials() : GrpcService_GoogleGrpc_ChannelCredentials(nullptr) {}
  ~GrpcService_GoogleGrpc_ChannelCredentials() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc_ChannelCredentials(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc_ChannelCredentials(const GrpcService_GoogleGrpc_ChannelCredentials& from) : GrpcService_GoogleGrpc_ChannelCredentials(nullptr, from) {}
  inline GrpcService_GoogleGrpc_ChannelCredentials(GrpcService_GoogleGrpc_ChannelCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_ChannelCredentials(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc_ChannelCredentials& operator=(const GrpcService_GoogleGrpc_ChannelCredentials& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc_ChannelCredentials& operator=(GrpcService_GoogleGrpc_ChannelCredentials&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc_ChannelCredentials& default_instance() {
    return *internal_default_instance();
  }
  enum CredentialSpecifierCase {
    kSslCredentials = 1,
    kGoogleDefault = 2,
    kLocalCredentials = 3,
    CREDENTIAL_SPECIFIER_NOT_SET = 0,
  };
  static inline const GrpcService_GoogleGrpc_ChannelCredentials* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc_ChannelCredentials*>(
        &_GrpcService_GoogleGrpc_ChannelCredentials_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(GrpcService_GoogleGrpc_ChannelCredentials& a, GrpcService_GoogleGrpc_ChannelCredentials& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc_ChannelCredentials* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc_ChannelCredentials* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc_ChannelCredentials* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc_ChannelCredentials>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc_ChannelCredentials& from);
  void MergeFrom(const GrpcService_GoogleGrpc_ChannelCredentials& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc_ChannelCredentials* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc.ChannelCredentials"; }

 protected:
  explicit GrpcService_GoogleGrpc_ChannelCredentials(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc_ChannelCredentials(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc_ChannelCredentials& from);
  GrpcService_GoogleGrpc_ChannelCredentials(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc_ChannelCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_ChannelCredentials(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kSslCredentialsFieldNumber = 1,
    kGoogleDefaultFieldNumber = 2,
    kLocalCredentialsFieldNumber = 3,
  };
  // .GrpcService.GoogleGrpc.SslCredentials ssl_credentials = 1;
  bool has_ssl_credentials() const;
  private:
  bool _internal_has_ssl_credentials() const;

  public:
  void clear_ssl_credentials() ;
  const ::GrpcService_GoogleGrpc_SslCredentials& ssl_credentials() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc_SslCredentials* release_ssl_credentials();
  ::GrpcService_GoogleGrpc_SslCredentials* mutable_ssl_credentials();
  void set_allocated_ssl_credentials(::GrpcService_GoogleGrpc_SslCredentials* value);
  void unsafe_arena_set_allocated_ssl_credentials(::GrpcService_GoogleGrpc_SslCredentials* value);
  ::GrpcService_GoogleGrpc_SslCredentials* unsafe_arena_release_ssl_credentials();

  private:
  const ::GrpcService_GoogleGrpc_SslCredentials& _internal_ssl_credentials() const;
  ::GrpcService_GoogleGrpc_SslCredentials* _internal_mutable_ssl_credentials();

  public:
  // .GrpcService.GoogleGrpc.Empty google_default = 2;
  bool has_google_default() const;
  private:
  bool _internal_has_google_default() const;

  public:
  void clear_google_default() ;
  const ::GrpcService_GoogleGrpc_Empty& google_default() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc_Empty* release_google_default();
  ::GrpcService_GoogleGrpc_Empty* mutable_google_default();
  void set_allocated_google_default(::GrpcService_GoogleGrpc_Empty* value);
  void unsafe_arena_set_allocated_google_default(::GrpcService_GoogleGrpc_Empty* value);
  ::GrpcService_GoogleGrpc_Empty* unsafe_arena_release_google_default();

  private:
  const ::GrpcService_GoogleGrpc_Empty& _internal_google_default() const;
  ::GrpcService_GoogleGrpc_Empty* _internal_mutable_google_default();

  public:
  // .GrpcService.GoogleGrpc.GoogleLocalCredentials local_credentials = 3;
  bool has_local_credentials() const;
  private:
  bool _internal_has_local_credentials() const;

  public:
  void clear_local_credentials() ;
  const ::GrpcService_GoogleGrpc_GoogleLocalCredentials& local_credentials() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc_GoogleLocalCredentials* release_local_credentials();
  ::GrpcService_GoogleGrpc_GoogleLocalCredentials* mutable_local_credentials();
  void set_allocated_local_credentials(::GrpcService_GoogleGrpc_GoogleLocalCredentials* value);
  void unsafe_arena_set_allocated_local_credentials(::GrpcService_GoogleGrpc_GoogleLocalCredentials* value);
  ::GrpcService_GoogleGrpc_GoogleLocalCredentials* unsafe_arena_release_local_credentials();

  private:
  const ::GrpcService_GoogleGrpc_GoogleLocalCredentials& _internal_local_credentials() const;
  ::GrpcService_GoogleGrpc_GoogleLocalCredentials* _internal_mutable_local_credentials();

  public:
  void clear_credential_specifier();
  CredentialSpecifierCase credential_specifier_case() const;
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc.ChannelCredentials)
 private:
  class _Internal;
  void set_has_ssl_credentials();
  void set_has_google_default();
  void set_has_local_credentials();
  inline bool has_credential_specifier() const;
  inline void clear_has_credential_specifier();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 3, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    union CredentialSpecifierUnion {
      constexpr CredentialSpecifierUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::GrpcService_GoogleGrpc_SslCredentials* ssl_credentials_;
      ::GrpcService_GoogleGrpc_Empty* google_default_;
      ::GrpcService_GoogleGrpc_GoogleLocalCredentials* local_credentials_;
    } credential_specifier_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc_CallCredentials final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc.CallCredentials) */ {
 public:
  inline GrpcService_GoogleGrpc_CallCredentials() : GrpcService_GoogleGrpc_CallCredentials(nullptr) {}
  ~GrpcService_GoogleGrpc_CallCredentials() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc_CallCredentials(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc_CallCredentials(const GrpcService_GoogleGrpc_CallCredentials& from) : GrpcService_GoogleGrpc_CallCredentials(nullptr, from) {}
  inline GrpcService_GoogleGrpc_CallCredentials(GrpcService_GoogleGrpc_CallCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc_CallCredentials& operator=(const GrpcService_GoogleGrpc_CallCredentials& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc_CallCredentials& operator=(GrpcService_GoogleGrpc_CallCredentials&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc_CallCredentials& default_instance() {
    return *internal_default_instance();
  }
  enum CredentialSpecifierCase {
    kAccessToken = 1,
    kGoogleComputeEngine = 2,
    kGoogleRefreshToken = 3,
    kServiceAccountJwtAccess = 4,
    kGoogleIam = 5,
    kFromPlugin = 6,
    kStsService = 7,
    CREDENTIAL_SPECIFIER_NOT_SET = 0,
  };
  static inline const GrpcService_GoogleGrpc_CallCredentials* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc_CallCredentials*>(
        &_GrpcService_GoogleGrpc_CallCredentials_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 12;
  friend void swap(GrpcService_GoogleGrpc_CallCredentials& a, GrpcService_GoogleGrpc_CallCredentials& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc_CallCredentials* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc_CallCredentials* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc_CallCredentials* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc_CallCredentials>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc_CallCredentials& from);
  void MergeFrom(const GrpcService_GoogleGrpc_CallCredentials& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc_CallCredentials* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc.CallCredentials"; }

 protected:
  explicit GrpcService_GoogleGrpc_CallCredentials(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc_CallCredentials(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc_CallCredentials& from);
  GrpcService_GoogleGrpc_CallCredentials(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc_CallCredentials&& from) noexcept
      : GrpcService_GoogleGrpc_CallCredentials(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------
  using ServiceAccountJWTAccessCredentials = GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials;
  using GoogleIAMCredentials = GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials;
  using MetadataCredentialsFromPlugin = GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin;
  using StsService = GrpcService_GoogleGrpc_CallCredentials_StsService;

  // accessors -------------------------------------------------------
  enum : int {
    kAccessTokenFieldNumber = 1,
    kGoogleComputeEngineFieldNumber = 2,
    kGoogleRefreshTokenFieldNumber = 3,
    kServiceAccountJwtAccessFieldNumber = 4,
    kGoogleIamFieldNumber = 5,
    kFromPluginFieldNumber = 6,
    kStsServiceFieldNumber = 7,
  };
  // string access_token = 1;
  bool has_access_token() const;
  void clear_access_token() ;
  const std::string& access_token() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_access_token(Arg_&& arg, Args_... args);
  std::string* mutable_access_token();
  PROTOBUF_NODISCARD std::string* release_access_token();
  void set_allocated_access_token(std::string* value);

  private:
  const std::string& _internal_access_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_access_token(
      const std::string& value);
  std::string* _internal_mutable_access_token();

  public:
  // .GrpcService.GoogleGrpc.Empty google_compute_engine = 2;
  bool has_google_compute_engine() const;
  private:
  bool _internal_has_google_compute_engine() const;

  public:
  void clear_google_compute_engine() ;
  const ::GrpcService_GoogleGrpc_Empty& google_compute_engine() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc_Empty* release_google_compute_engine();
  ::GrpcService_GoogleGrpc_Empty* mutable_google_compute_engine();
  void set_allocated_google_compute_engine(::GrpcService_GoogleGrpc_Empty* value);
  void unsafe_arena_set_allocated_google_compute_engine(::GrpcService_GoogleGrpc_Empty* value);
  ::GrpcService_GoogleGrpc_Empty* unsafe_arena_release_google_compute_engine();

  private:
  const ::GrpcService_GoogleGrpc_Empty& _internal_google_compute_engine() const;
  ::GrpcService_GoogleGrpc_Empty* _internal_mutable_google_compute_engine();

  public:
  // string google_refresh_token = 3;
  bool has_google_refresh_token() const;
  void clear_google_refresh_token() ;
  const std::string& google_refresh_token() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_google_refresh_token(Arg_&& arg, Args_... args);
  std::string* mutable_google_refresh_token();
  PROTOBUF_NODISCARD std::string* release_google_refresh_token();
  void set_allocated_google_refresh_token(std::string* value);

  private:
  const std::string& _internal_google_refresh_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_google_refresh_token(
      const std::string& value);
  std::string* _internal_mutable_google_refresh_token();

  public:
  // .GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials service_account_jwt_access = 4;
  bool has_service_account_jwt_access() const;
  private:
  bool _internal_has_service_account_jwt_access() const;

  public:
  void clear_service_account_jwt_access() ;
  const ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& service_account_jwt_access() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* release_service_account_jwt_access();
  ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* mutable_service_account_jwt_access();
  void set_allocated_service_account_jwt_access(::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* value);
  void unsafe_arena_set_allocated_service_account_jwt_access(::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* value);
  ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* unsafe_arena_release_service_account_jwt_access();

  private:
  const ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& _internal_service_account_jwt_access() const;
  ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* _internal_mutable_service_account_jwt_access();

  public:
  // .GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials google_iam = 5;
  bool has_google_iam() const;
  private:
  bool _internal_has_google_iam() const;

  public:
  void clear_google_iam() ;
  const ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& google_iam() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* release_google_iam();
  ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* mutable_google_iam();
  void set_allocated_google_iam(::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* value);
  void unsafe_arena_set_allocated_google_iam(::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* value);
  ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* unsafe_arena_release_google_iam();

  private:
  const ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& _internal_google_iam() const;
  ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* _internal_mutable_google_iam();

  public:
  // .GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin from_plugin = 6;
  bool has_from_plugin() const;
  private:
  bool _internal_has_from_plugin() const;

  public:
  void clear_from_plugin() ;
  const ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& from_plugin() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* release_from_plugin();
  ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* mutable_from_plugin();
  void set_allocated_from_plugin(::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* value);
  void unsafe_arena_set_allocated_from_plugin(::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* value);
  ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* unsafe_arena_release_from_plugin();

  private:
  const ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& _internal_from_plugin() const;
  ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* _internal_mutable_from_plugin();

  public:
  // .GrpcService.GoogleGrpc.CallCredentials.StsService sts_service = 7;
  bool has_sts_service() const;
  private:
  bool _internal_has_sts_service() const;

  public:
  void clear_sts_service() ;
  const ::GrpcService_GoogleGrpc_CallCredentials_StsService& sts_service() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc_CallCredentials_StsService* release_sts_service();
  ::GrpcService_GoogleGrpc_CallCredentials_StsService* mutable_sts_service();
  void set_allocated_sts_service(::GrpcService_GoogleGrpc_CallCredentials_StsService* value);
  void unsafe_arena_set_allocated_sts_service(::GrpcService_GoogleGrpc_CallCredentials_StsService* value);
  ::GrpcService_GoogleGrpc_CallCredentials_StsService* unsafe_arena_release_sts_service();

  private:
  const ::GrpcService_GoogleGrpc_CallCredentials_StsService& _internal_sts_service() const;
  ::GrpcService_GoogleGrpc_CallCredentials_StsService* _internal_mutable_sts_service();

  public:
  void clear_credential_specifier();
  CredentialSpecifierCase credential_specifier_case() const;
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc.CallCredentials)
 private:
  class _Internal;
  void set_has_access_token();
  void set_has_google_compute_engine();
  void set_has_google_refresh_token();
  void set_has_service_account_jwt_access();
  void set_has_google_iam();
  void set_has_from_plugin();
  void set_has_sts_service();
  inline bool has_credential_specifier() const;
  inline void clear_has_credential_specifier();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 7, 5,
      79, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    union CredentialSpecifierUnion {
      constexpr CredentialSpecifierUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::internal::ArenaStringPtr access_token_;
      ::GrpcService_GoogleGrpc_Empty* google_compute_engine_;
      ::google::protobuf::internal::ArenaStringPtr google_refresh_token_;
      ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* service_account_jwt_access_;
      ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* google_iam_;
      ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* from_plugin_;
      ::GrpcService_GoogleGrpc_CallCredentials_StsService* sts_service_;
    } credential_specifier_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService_GoogleGrpc final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService.GoogleGrpc) */ {
 public:
  inline GrpcService_GoogleGrpc() : GrpcService_GoogleGrpc(nullptr) {}
  ~GrpcService_GoogleGrpc() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService_GoogleGrpc(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService_GoogleGrpc(const GrpcService_GoogleGrpc& from) : GrpcService_GoogleGrpc(nullptr, from) {}
  inline GrpcService_GoogleGrpc(GrpcService_GoogleGrpc&& from) noexcept
      : GrpcService_GoogleGrpc(nullptr, std::move(from)) {}
  inline GrpcService_GoogleGrpc& operator=(const GrpcService_GoogleGrpc& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService_GoogleGrpc& operator=(GrpcService_GoogleGrpc&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService_GoogleGrpc& default_instance() {
    return *internal_default_instance();
  }
  static inline const GrpcService_GoogleGrpc* internal_default_instance() {
    return reinterpret_cast<const GrpcService_GoogleGrpc*>(
        &_GrpcService_GoogleGrpc_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 13;
  friend void swap(GrpcService_GoogleGrpc& a, GrpcService_GoogleGrpc& b) { a.Swap(&b); }
  inline void Swap(GrpcService_GoogleGrpc* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService_GoogleGrpc* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService_GoogleGrpc* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService_GoogleGrpc>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService_GoogleGrpc& from);
  void MergeFrom(const GrpcService_GoogleGrpc& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService_GoogleGrpc* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService.GoogleGrpc"; }

 protected:
  explicit GrpcService_GoogleGrpc(::google::protobuf::Arena* arena);
  GrpcService_GoogleGrpc(::google::protobuf::Arena* arena, const GrpcService_GoogleGrpc& from);
  GrpcService_GoogleGrpc(::google::protobuf::Arena* arena, GrpcService_GoogleGrpc&& from) noexcept
      : GrpcService_GoogleGrpc(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------
  using SslCredentials = GrpcService_GoogleGrpc_SslCredentials;
  using GoogleLocalCredentials = GrpcService_GoogleGrpc_GoogleLocalCredentials;
  using Empty = GrpcService_GoogleGrpc_Empty;
  using ChannelCredentials = GrpcService_GoogleGrpc_ChannelCredentials;
  using CallCredentials = GrpcService_GoogleGrpc_CallCredentials;

  // accessors -------------------------------------------------------
  enum : int {
    kCallCredentialsFieldNumber = 3,
    kTargetUriFieldNumber = 1,
    kStatPrefixFieldNumber = 4,
    kCredentialsFactoryNameFieldNumber = 5,
    kChannelCredentialsFieldNumber = 2,
    kConfigFieldNumber = 6,
  };
  // repeated .GrpcService.GoogleGrpc.CallCredentials call_credentials = 3;
  int call_credentials_size() const;
  private:
  int _internal_call_credentials_size() const;

  public:
  void clear_call_credentials() ;
  ::GrpcService_GoogleGrpc_CallCredentials* mutable_call_credentials(int index);
  ::google::protobuf::RepeatedPtrField<::GrpcService_GoogleGrpc_CallCredentials>* mutable_call_credentials();

  private:
  const ::google::protobuf::RepeatedPtrField<::GrpcService_GoogleGrpc_CallCredentials>& _internal_call_credentials() const;
  ::google::protobuf::RepeatedPtrField<::GrpcService_GoogleGrpc_CallCredentials>* _internal_mutable_call_credentials();
  public:
  const ::GrpcService_GoogleGrpc_CallCredentials& call_credentials(int index) const;
  ::GrpcService_GoogleGrpc_CallCredentials* add_call_credentials();
  const ::google::protobuf::RepeatedPtrField<::GrpcService_GoogleGrpc_CallCredentials>& call_credentials() const;
  // string target_uri = 1;
  void clear_target_uri() ;
  const std::string& target_uri() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_target_uri(Arg_&& arg, Args_... args);
  std::string* mutable_target_uri();
  PROTOBUF_NODISCARD std::string* release_target_uri();
  void set_allocated_target_uri(std::string* value);

  private:
  const std::string& _internal_target_uri() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_target_uri(
      const std::string& value);
  std::string* _internal_mutable_target_uri();

  public:
  // string stat_prefix = 4;
  void clear_stat_prefix() ;
  const std::string& stat_prefix() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_stat_prefix(Arg_&& arg, Args_... args);
  std::string* mutable_stat_prefix();
  PROTOBUF_NODISCARD std::string* release_stat_prefix();
  void set_allocated_stat_prefix(std::string* value);

  private:
  const std::string& _internal_stat_prefix() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stat_prefix(
      const std::string& value);
  std::string* _internal_mutable_stat_prefix();

  public:
  // string credentials_factory_name = 5;
  void clear_credentials_factory_name() ;
  const std::string& credentials_factory_name() const;
  template <typename Arg_ = const std::string&, typename... Args_>
  void set_credentials_factory_name(Arg_&& arg, Args_... args);
  std::string* mutable_credentials_factory_name();
  PROTOBUF_NODISCARD std::string* release_credentials_factory_name();
  void set_allocated_credentials_factory_name(std::string* value);

  private:
  const std::string& _internal_credentials_factory_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_credentials_factory_name(
      const std::string& value);
  std::string* _internal_mutable_credentials_factory_name();

  public:
  // .GrpcService.GoogleGrpc.ChannelCredentials channel_credentials = 2;
  bool has_channel_credentials() const;
  void clear_channel_credentials() ;
  const ::GrpcService_GoogleGrpc_ChannelCredentials& channel_credentials() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc_ChannelCredentials* release_channel_credentials();
  ::GrpcService_GoogleGrpc_ChannelCredentials* mutable_channel_credentials();
  void set_allocated_channel_credentials(::GrpcService_GoogleGrpc_ChannelCredentials* value);
  void unsafe_arena_set_allocated_channel_credentials(::GrpcService_GoogleGrpc_ChannelCredentials* value);
  ::GrpcService_GoogleGrpc_ChannelCredentials* unsafe_arena_release_channel_credentials();

  private:
  const ::GrpcService_GoogleGrpc_ChannelCredentials& _internal_channel_credentials() const;
  ::GrpcService_GoogleGrpc_ChannelCredentials* _internal_mutable_channel_credentials();

  public:
  // .google.protobuf.Struct config = 6;
  bool has_config() const;
  void clear_config() ;
  const ::google::protobuf::Struct& config() const;
  PROTOBUF_NODISCARD ::google::protobuf::Struct* release_config();
  ::google::protobuf::Struct* mutable_config();
  void set_allocated_config(::google::protobuf::Struct* value);
  void unsafe_arena_set_allocated_config(::google::protobuf::Struct* value);
  ::google::protobuf::Struct* unsafe_arena_release_config();

  private:
  const ::google::protobuf::Struct& _internal_config() const;
  ::google::protobuf::Struct* _internal_mutable_config();

  public:
  // @@protoc_insertion_point(class_scope:GrpcService.GoogleGrpc)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      3, 6, 3,
      76, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::GrpcService_GoogleGrpc_CallCredentials > call_credentials_;
    ::google::protobuf::internal::ArenaStringPtr target_uri_;
    ::google::protobuf::internal::ArenaStringPtr stat_prefix_;
    ::google::protobuf::internal::ArenaStringPtr credentials_factory_name_;
    ::GrpcService_GoogleGrpc_ChannelCredentials* channel_credentials_;
    ::google::protobuf::Struct* config_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};
// -------------------------------------------------------------------

class GrpcService final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:GrpcService) */ {
 public:
  inline GrpcService() : GrpcService(nullptr) {}
  ~GrpcService() override;
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR GrpcService(
      ::google::protobuf::internal::ConstantInitialized);

  inline GrpcService(const GrpcService& from) : GrpcService(nullptr, from) {}
  inline GrpcService(GrpcService&& from) noexcept
      : GrpcService(nullptr, std::move(from)) {}
  inline GrpcService& operator=(const GrpcService& from) {
    CopyFrom(from);
    return *this;
  }
  inline GrpcService& operator=(GrpcService&& from) noexcept {
    if (this == &from) return *this;
    if (GetArena() == from.GetArena()
#ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetArena() != nullptr
#endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const GrpcService& default_instance() {
    return *internal_default_instance();
  }
  enum TargetSpecifierCase {
    kEnvoyGrpc = 1,
    kGoogleGrpc = 2,
    TARGET_SPECIFIER_NOT_SET = 0,
  };
  static inline const GrpcService* internal_default_instance() {
    return reinterpret_cast<const GrpcService*>(
        &_GrpcService_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 15;
  friend void swap(GrpcService& a, GrpcService& b) { a.Swap(&b); }
  inline void Swap(GrpcService* other) {
    if (other == this) return;
#ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() != nullptr && GetArena() == other->GetArena()) {
#else   // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetArena() == other->GetArena()) {
#endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GrpcService* other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  GrpcService* New(::google::protobuf::Arena* arena = nullptr) const final {
    return ::google::protobuf::MessageLite::DefaultConstruct<GrpcService>(arena);
  }
  void CheckTypeAndMergeFrom(
      const ::google::protobuf::MessageLite& from) final;
  void CopyFrom(const GrpcService& from);
  void MergeFrom(const GrpcService& from);
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  ::size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::google::protobuf::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target,
      ::google::protobuf::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::google::protobuf::Arena* arena);
  void SharedDtor();
  void InternalSwap(GrpcService* other);
 private:
  friend class ::google::protobuf::internal::AnyMetadata;
  static ::absl::string_view FullMessageName() { return "GrpcService"; }

 protected:
  explicit GrpcService(::google::protobuf::Arena* arena);
  GrpcService(::google::protobuf::Arena* arena, const GrpcService& from);
  GrpcService(::google::protobuf::Arena* arena, GrpcService&& from) noexcept
      : GrpcService(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::MessageLite::ClassData* GetClassData()
      const final;

 public:
  // nested types ----------------------------------------------------
  using EnvoyGrpc = GrpcService_EnvoyGrpc;
  using GoogleGrpc = GrpcService_GoogleGrpc;
  using HeaderValue = GrpcService_HeaderValue;

  // accessors -------------------------------------------------------
  enum : int {
    kInitialMetadataFieldNumber = 5,
    kEnvoyGrpcFieldNumber = 1,
    kGoogleGrpcFieldNumber = 2,
  };
  // repeated .GrpcService.HeaderValue initial_metadata = 5;
  int initial_metadata_size() const;
  private:
  int _internal_initial_metadata_size() const;

  public:
  void clear_initial_metadata() ;
  ::GrpcService_HeaderValue* mutable_initial_metadata(int index);
  ::google::protobuf::RepeatedPtrField<::GrpcService_HeaderValue>* mutable_initial_metadata();

  private:
  const ::google::protobuf::RepeatedPtrField<::GrpcService_HeaderValue>& _internal_initial_metadata() const;
  ::google::protobuf::RepeatedPtrField<::GrpcService_HeaderValue>* _internal_mutable_initial_metadata();
  public:
  const ::GrpcService_HeaderValue& initial_metadata(int index) const;
  ::GrpcService_HeaderValue* add_initial_metadata();
  const ::google::protobuf::RepeatedPtrField<::GrpcService_HeaderValue>& initial_metadata() const;
  // .GrpcService.EnvoyGrpc envoy_grpc = 1;
  bool has_envoy_grpc() const;
  private:
  bool _internal_has_envoy_grpc() const;

  public:
  void clear_envoy_grpc() ;
  const ::GrpcService_EnvoyGrpc& envoy_grpc() const;
  PROTOBUF_NODISCARD ::GrpcService_EnvoyGrpc* release_envoy_grpc();
  ::GrpcService_EnvoyGrpc* mutable_envoy_grpc();
  void set_allocated_envoy_grpc(::GrpcService_EnvoyGrpc* value);
  void unsafe_arena_set_allocated_envoy_grpc(::GrpcService_EnvoyGrpc* value);
  ::GrpcService_EnvoyGrpc* unsafe_arena_release_envoy_grpc();

  private:
  const ::GrpcService_EnvoyGrpc& _internal_envoy_grpc() const;
  ::GrpcService_EnvoyGrpc* _internal_mutable_envoy_grpc();

  public:
  // .GrpcService.GoogleGrpc google_grpc = 2;
  bool has_google_grpc() const;
  private:
  bool _internal_has_google_grpc() const;

  public:
  void clear_google_grpc() ;
  const ::GrpcService_GoogleGrpc& google_grpc() const;
  PROTOBUF_NODISCARD ::GrpcService_GoogleGrpc* release_google_grpc();
  ::GrpcService_GoogleGrpc* mutable_google_grpc();
  void set_allocated_google_grpc(::GrpcService_GoogleGrpc* value);
  void unsafe_arena_set_allocated_google_grpc(::GrpcService_GoogleGrpc* value);
  ::GrpcService_GoogleGrpc* unsafe_arena_release_google_grpc();

  private:
  const ::GrpcService_GoogleGrpc& _internal_google_grpc() const;
  ::GrpcService_GoogleGrpc* _internal_mutable_google_grpc();

  public:
  void clear_target_specifier();
  TargetSpecifierCase target_specifier_case() const;
  // @@protoc_insertion_point(class_scope:GrpcService)
 private:
  class _Internal;
  void set_has_envoy_grpc();
  void set_has_google_grpc();
  inline bool has_target_specifier() const;
  inline void clear_has_target_specifier();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<
      0, 3, 3,
      0, 2>
      _table_;
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(
        ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena);
    inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility,
                          ::google::protobuf::Arena* arena, const Impl_& from);
    ::google::protobuf::RepeatedPtrField< ::GrpcService_HeaderValue > initial_metadata_;
    union TargetSpecifierUnion {
      constexpr TargetSpecifierUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::GrpcService_EnvoyGrpc* envoy_grpc_;
      ::GrpcService_GoogleGrpc* google_grpc_;
    } target_specifier_;
    mutable ::google::protobuf::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_proxy_5fwasm_5fintrinsics_5flite_2eproto;
};

// ===================================================================




// ===================================================================


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// WKT

// .google.protobuf.Struct struct = 1;
inline bool WKT::has_struct_() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.struct__ != nullptr);
  return value;
}
inline const ::google::protobuf::Struct& WKT::_internal_struct_() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::google::protobuf::Struct* p = _impl_.struct__;
  return p != nullptr ? *p : reinterpret_cast<const ::google::protobuf::Struct&>(::google::protobuf::_Struct_default_instance_);
}
inline const ::google::protobuf::Struct& WKT::struct_() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:WKT.struct)
  return _internal_struct_();
}
inline void WKT::unsafe_arena_set_allocated_struct_(::google::protobuf::Struct* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.struct__);
  }
  _impl_.struct__ = reinterpret_cast<::google::protobuf::Struct*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:WKT.struct)
}
inline ::google::protobuf::Struct* WKT::release_struct_() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::google::protobuf::Struct* released = _impl_.struct__;
  _impl_.struct__ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::google::protobuf::Struct* WKT::unsafe_arena_release_struct_() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:WKT.struct)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::google::protobuf::Struct* temp = _impl_.struct__;
  _impl_.struct__ = nullptr;
  return temp;
}
inline ::google::protobuf::Struct* WKT::_internal_mutable_struct_() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.struct__ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::google::protobuf::Struct>(GetArena());
    _impl_.struct__ = reinterpret_cast<::google::protobuf::Struct*>(p);
  }
  return _impl_.struct__;
}
inline ::google::protobuf::Struct* WKT::mutable_struct_() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::google::protobuf::Struct* _msg = _internal_mutable_struct_();
  // @@protoc_insertion_point(field_mutable:WKT.struct)
  return _msg;
}
inline void WKT::set_allocated_struct_(::google::protobuf::Struct* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.struct__);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.struct__ = reinterpret_cast<::google::protobuf::Struct*>(value);
  // @@protoc_insertion_point(field_set_allocated:WKT.struct)
}

// -------------------------------------------------------------------

// DataSource

// string filename = 1;
inline bool DataSource::has_filename() const {
  return specifier_case() == kFilename;
}
inline void DataSource::set_has_filename() {
  _impl_._oneof_case_[0] = kFilename;
}
inline void DataSource::clear_filename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() == kFilename) {
    _impl_.specifier_.filename_.Destroy();
    clear_has_specifier();
  }
}
inline const std::string& DataSource::filename() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:DataSource.filename)
  return _internal_filename();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DataSource::set_filename(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() != kFilename) {
    clear_specifier();

    set_has_filename();
    _impl_.specifier_.filename_.InitDefault();
  }
  _impl_.specifier_.filename_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:DataSource.filename)
}
inline std::string* DataSource::mutable_filename() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:DataSource.filename)
  return _s;
}
inline const std::string& DataSource::_internal_filename() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  if (specifier_case() != kFilename) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.specifier_.filename_.Get();
}
inline void DataSource::_internal_set_filename(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() != kFilename) {
    clear_specifier();

    set_has_filename();
    _impl_.specifier_.filename_.InitDefault();
  }
  _impl_.specifier_.filename_.Set(value, GetArena());
}
inline std::string* DataSource::_internal_mutable_filename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() != kFilename) {
    clear_specifier();

    set_has_filename();
    _impl_.specifier_.filename_.InitDefault();
  }
  return _impl_.specifier_.filename_.Mutable( GetArena());
}
inline std::string* DataSource::release_filename() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:DataSource.filename)
  if (specifier_case() != kFilename) {
    return nullptr;
  }
  clear_has_specifier();
  return _impl_.specifier_.filename_.Release();
}
inline void DataSource::set_allocated_filename(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (has_specifier()) {
    clear_specifier();
  }
  if (value != nullptr) {
    set_has_filename();
    _impl_.specifier_.filename_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:DataSource.filename)
}

// bytes inline_bytes = 2;
inline bool DataSource::has_inline_bytes() const {
  return specifier_case() == kInlineBytes;
}
inline void DataSource::set_has_inline_bytes() {
  _impl_._oneof_case_[0] = kInlineBytes;
}
inline void DataSource::clear_inline_bytes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() == kInlineBytes) {
    _impl_.specifier_.inline_bytes_.Destroy();
    clear_has_specifier();
  }
}
inline const std::string& DataSource::inline_bytes() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:DataSource.inline_bytes)
  return _internal_inline_bytes();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DataSource::set_inline_bytes(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() != kInlineBytes) {
    clear_specifier();

    set_has_inline_bytes();
    _impl_.specifier_.inline_bytes_.InitDefault();
  }
  _impl_.specifier_.inline_bytes_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:DataSource.inline_bytes)
}
inline std::string* DataSource::mutable_inline_bytes() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_inline_bytes();
  // @@protoc_insertion_point(field_mutable:DataSource.inline_bytes)
  return _s;
}
inline const std::string& DataSource::_internal_inline_bytes() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  if (specifier_case() != kInlineBytes) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.specifier_.inline_bytes_.Get();
}
inline void DataSource::_internal_set_inline_bytes(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() != kInlineBytes) {
    clear_specifier();

    set_has_inline_bytes();
    _impl_.specifier_.inline_bytes_.InitDefault();
  }
  _impl_.specifier_.inline_bytes_.Set(value, GetArena());
}
inline std::string* DataSource::_internal_mutable_inline_bytes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() != kInlineBytes) {
    clear_specifier();

    set_has_inline_bytes();
    _impl_.specifier_.inline_bytes_.InitDefault();
  }
  return _impl_.specifier_.inline_bytes_.Mutable( GetArena());
}
inline std::string* DataSource::release_inline_bytes() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:DataSource.inline_bytes)
  if (specifier_case() != kInlineBytes) {
    return nullptr;
  }
  clear_has_specifier();
  return _impl_.specifier_.inline_bytes_.Release();
}
inline void DataSource::set_allocated_inline_bytes(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (has_specifier()) {
    clear_specifier();
  }
  if (value != nullptr) {
    set_has_inline_bytes();
    _impl_.specifier_.inline_bytes_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:DataSource.inline_bytes)
}

// string inline_string = 3;
inline bool DataSource::has_inline_string() const {
  return specifier_case() == kInlineString;
}
inline void DataSource::set_has_inline_string() {
  _impl_._oneof_case_[0] = kInlineString;
}
inline void DataSource::clear_inline_string() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() == kInlineString) {
    _impl_.specifier_.inline_string_.Destroy();
    clear_has_specifier();
  }
}
inline const std::string& DataSource::inline_string() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:DataSource.inline_string)
  return _internal_inline_string();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void DataSource::set_inline_string(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() != kInlineString) {
    clear_specifier();

    set_has_inline_string();
    _impl_.specifier_.inline_string_.InitDefault();
  }
  _impl_.specifier_.inline_string_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:DataSource.inline_string)
}
inline std::string* DataSource::mutable_inline_string() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_inline_string();
  // @@protoc_insertion_point(field_mutable:DataSource.inline_string)
  return _s;
}
inline const std::string& DataSource::_internal_inline_string() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  if (specifier_case() != kInlineString) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.specifier_.inline_string_.Get();
}
inline void DataSource::_internal_set_inline_string(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() != kInlineString) {
    clear_specifier();

    set_has_inline_string();
    _impl_.specifier_.inline_string_.InitDefault();
  }
  _impl_.specifier_.inline_string_.Set(value, GetArena());
}
inline std::string* DataSource::_internal_mutable_inline_string() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (specifier_case() != kInlineString) {
    clear_specifier();

    set_has_inline_string();
    _impl_.specifier_.inline_string_.InitDefault();
  }
  return _impl_.specifier_.inline_string_.Mutable( GetArena());
}
inline std::string* DataSource::release_inline_string() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:DataSource.inline_string)
  if (specifier_case() != kInlineString) {
    return nullptr;
  }
  clear_has_specifier();
  return _impl_.specifier_.inline_string_.Release();
}
inline void DataSource::set_allocated_inline_string(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (has_specifier()) {
    clear_specifier();
  }
  if (value != nullptr) {
    set_has_inline_string();
    _impl_.specifier_.inline_string_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:DataSource.inline_string)
}

inline bool DataSource::has_specifier() const {
  return specifier_case() != SPECIFIER_NOT_SET;
}
inline void DataSource::clear_has_specifier() {
  _impl_._oneof_case_[0] = SPECIFIER_NOT_SET;
}
inline DataSource::SpecifierCase DataSource::specifier_case() const {
  return DataSource::SpecifierCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Any

// string type_url = 1;
inline void Any::clear_type_url() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_url_.ClearToEmpty();
}
inline const std::string& Any::type_url() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:Any.type_url)
  return _internal_type_url();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Any::set_type_url(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_url_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:Any.type_url)
}
inline std::string* Any::mutable_type_url() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_type_url();
  // @@protoc_insertion_point(field_mutable:Any.type_url)
  return _s;
}
inline const std::string& Any::_internal_type_url() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.type_url_.Get();
}
inline void Any::_internal_set_type_url(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_url_.Set(value, GetArena());
}
inline std::string* Any::_internal_mutable_type_url() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.type_url_.Mutable( GetArena());
}
inline std::string* Any::release_type_url() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:Any.type_url)
  return _impl_.type_url_.Release();
}
inline void Any::set_allocated_type_url(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.type_url_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.type_url_.IsDefault()) {
          _impl_.type_url_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Any.type_url)
}

// bytes value = 2;
inline void Any::clear_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.value_.ClearToEmpty();
}
inline const std::string& Any::value() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:Any.value)
  return _internal_value();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void Any::set_value(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.value_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:Any.value)
}
inline std::string* Any::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:Any.value)
  return _s;
}
inline const std::string& Any::_internal_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.value_.Get();
}
inline void Any::_internal_set_value(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.value_.Set(value, GetArena());
}
inline std::string* Any::_internal_mutable_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.value_.Mutable( GetArena());
}
inline std::string* Any::release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:Any.value)
  return _impl_.value_.Release();
}
inline void Any::set_allocated_value(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.value_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.value_.IsDefault()) {
          _impl_.value_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Any.value)
}

// -------------------------------------------------------------------

// GrpcService_EnvoyGrpc

// string cluster_name = 1;
inline void GrpcService_EnvoyGrpc::clear_cluster_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cluster_name_.ClearToEmpty();
}
inline const std::string& GrpcService_EnvoyGrpc::cluster_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.EnvoyGrpc.cluster_name)
  return _internal_cluster_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_EnvoyGrpc::set_cluster_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cluster_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.EnvoyGrpc.cluster_name)
}
inline std::string* GrpcService_EnvoyGrpc::mutable_cluster_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_cluster_name();
  // @@protoc_insertion_point(field_mutable:GrpcService.EnvoyGrpc.cluster_name)
  return _s;
}
inline const std::string& GrpcService_EnvoyGrpc::_internal_cluster_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.cluster_name_.Get();
}
inline void GrpcService_EnvoyGrpc::_internal_set_cluster_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cluster_name_.Set(value, GetArena());
}
inline std::string* GrpcService_EnvoyGrpc::_internal_mutable_cluster_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.cluster_name_.Mutable( GetArena());
}
inline std::string* GrpcService_EnvoyGrpc::release_cluster_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.EnvoyGrpc.cluster_name)
  return _impl_.cluster_name_.Release();
}
inline void GrpcService_EnvoyGrpc::set_allocated_cluster_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.cluster_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.cluster_name_.IsDefault()) {
          _impl_.cluster_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.EnvoyGrpc.cluster_name)
}

// -------------------------------------------------------------------

// GrpcService_GoogleGrpc_SslCredentials

// .DataSource root_certs = 1;
inline bool GrpcService_GoogleGrpc_SslCredentials::has_root_certs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.root_certs_ != nullptr);
  return value;
}
inline void GrpcService_GoogleGrpc_SslCredentials::clear_root_certs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.root_certs_ != nullptr) _impl_.root_certs_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::DataSource& GrpcService_GoogleGrpc_SslCredentials::_internal_root_certs() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::DataSource* p = _impl_.root_certs_;
  return p != nullptr ? *p : reinterpret_cast<const ::DataSource&>(::_DataSource_default_instance_);
}
inline const ::DataSource& GrpcService_GoogleGrpc_SslCredentials::root_certs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.SslCredentials.root_certs)
  return _internal_root_certs();
}
inline void GrpcService_GoogleGrpc_SslCredentials::unsafe_arena_set_allocated_root_certs(::DataSource* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.root_certs_);
  }
  _impl_.root_certs_ = reinterpret_cast<::DataSource*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.SslCredentials.root_certs)
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::release_root_certs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::DataSource* released = _impl_.root_certs_;
  _impl_.root_certs_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::unsafe_arena_release_root_certs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.SslCredentials.root_certs)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::DataSource* temp = _impl_.root_certs_;
  _impl_.root_certs_ = nullptr;
  return temp;
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::_internal_mutable_root_certs() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.root_certs_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::DataSource>(GetArena());
    _impl_.root_certs_ = reinterpret_cast<::DataSource*>(p);
  }
  return _impl_.root_certs_;
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::mutable_root_certs() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::DataSource* _msg = _internal_mutable_root_certs();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.SslCredentials.root_certs)
  return _msg;
}
inline void GrpcService_GoogleGrpc_SslCredentials::set_allocated_root_certs(::DataSource* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete (_impl_.root_certs_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.root_certs_ = reinterpret_cast<::DataSource*>(value);
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.SslCredentials.root_certs)
}

// .DataSource private_key = 2;
inline bool GrpcService_GoogleGrpc_SslCredentials::has_private_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.private_key_ != nullptr);
  return value;
}
inline void GrpcService_GoogleGrpc_SslCredentials::clear_private_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.private_key_ != nullptr) _impl_.private_key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::DataSource& GrpcService_GoogleGrpc_SslCredentials::_internal_private_key() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::DataSource* p = _impl_.private_key_;
  return p != nullptr ? *p : reinterpret_cast<const ::DataSource&>(::_DataSource_default_instance_);
}
inline const ::DataSource& GrpcService_GoogleGrpc_SslCredentials::private_key() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.SslCredentials.private_key)
  return _internal_private_key();
}
inline void GrpcService_GoogleGrpc_SslCredentials::unsafe_arena_set_allocated_private_key(::DataSource* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.private_key_);
  }
  _impl_.private_key_ = reinterpret_cast<::DataSource*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.SslCredentials.private_key)
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::release_private_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::DataSource* released = _impl_.private_key_;
  _impl_.private_key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::unsafe_arena_release_private_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.SslCredentials.private_key)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::DataSource* temp = _impl_.private_key_;
  _impl_.private_key_ = nullptr;
  return temp;
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::_internal_mutable_private_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.private_key_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::DataSource>(GetArena());
    _impl_.private_key_ = reinterpret_cast<::DataSource*>(p);
  }
  return _impl_.private_key_;
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::mutable_private_key() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000002u;
  ::DataSource* _msg = _internal_mutable_private_key();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.SslCredentials.private_key)
  return _msg;
}
inline void GrpcService_GoogleGrpc_SslCredentials::set_allocated_private_key(::DataSource* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete (_impl_.private_key_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.private_key_ = reinterpret_cast<::DataSource*>(value);
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.SslCredentials.private_key)
}

// .DataSource cert_chain = 3;
inline bool GrpcService_GoogleGrpc_SslCredentials::has_cert_chain() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cert_chain_ != nullptr);
  return value;
}
inline void GrpcService_GoogleGrpc_SslCredentials::clear_cert_chain() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.cert_chain_ != nullptr) _impl_.cert_chain_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::DataSource& GrpcService_GoogleGrpc_SslCredentials::_internal_cert_chain() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::DataSource* p = _impl_.cert_chain_;
  return p != nullptr ? *p : reinterpret_cast<const ::DataSource&>(::_DataSource_default_instance_);
}
inline const ::DataSource& GrpcService_GoogleGrpc_SslCredentials::cert_chain() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.SslCredentials.cert_chain)
  return _internal_cert_chain();
}
inline void GrpcService_GoogleGrpc_SslCredentials::unsafe_arena_set_allocated_cert_chain(::DataSource* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cert_chain_);
  }
  _impl_.cert_chain_ = reinterpret_cast<::DataSource*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.SslCredentials.cert_chain)
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::release_cert_chain() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::DataSource* released = _impl_.cert_chain_;
  _impl_.cert_chain_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::unsafe_arena_release_cert_chain() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.SslCredentials.cert_chain)

  _impl_._has_bits_[0] &= ~0x00000004u;
  ::DataSource* temp = _impl_.cert_chain_;
  _impl_.cert_chain_ = nullptr;
  return temp;
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::_internal_mutable_cert_chain() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.cert_chain_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::DataSource>(GetArena());
    _impl_.cert_chain_ = reinterpret_cast<::DataSource*>(p);
  }
  return _impl_.cert_chain_;
}
inline ::DataSource* GrpcService_GoogleGrpc_SslCredentials::mutable_cert_chain() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000004u;
  ::DataSource* _msg = _internal_mutable_cert_chain();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.SslCredentials.cert_chain)
  return _msg;
}
inline void GrpcService_GoogleGrpc_SslCredentials::set_allocated_cert_chain(::DataSource* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete (_impl_.cert_chain_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }

  _impl_.cert_chain_ = reinterpret_cast<::DataSource*>(value);
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.SslCredentials.cert_chain)
}

// -------------------------------------------------------------------

// GrpcService_GoogleGrpc_GoogleLocalCredentials

// -------------------------------------------------------------------

// GrpcService_GoogleGrpc_Empty

// -------------------------------------------------------------------

// GrpcService_GoogleGrpc_ChannelCredentials

// .GrpcService.GoogleGrpc.SslCredentials ssl_credentials = 1;
inline bool GrpcService_GoogleGrpc_ChannelCredentials::has_ssl_credentials() const {
  return credential_specifier_case() == kSslCredentials;
}
inline bool GrpcService_GoogleGrpc_ChannelCredentials::_internal_has_ssl_credentials() const {
  return credential_specifier_case() == kSslCredentials;
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::set_has_ssl_credentials() {
  _impl_._oneof_case_[0] = kSslCredentials;
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::clear_ssl_credentials() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kSslCredentials) {
    if (GetArena() == nullptr) {
      delete _impl_.credential_specifier_.ssl_credentials_;
    }
    clear_has_credential_specifier();
  }
}
inline ::GrpcService_GoogleGrpc_SslCredentials* GrpcService_GoogleGrpc_ChannelCredentials::release_ssl_credentials() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.ChannelCredentials.ssl_credentials)
  if (credential_specifier_case() == kSslCredentials) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.ssl_credentials_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.credential_specifier_.ssl_credentials_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_GoogleGrpc_SslCredentials& GrpcService_GoogleGrpc_ChannelCredentials::_internal_ssl_credentials() const {
  return credential_specifier_case() == kSslCredentials ? *_impl_.credential_specifier_.ssl_credentials_ : reinterpret_cast<::GrpcService_GoogleGrpc_SslCredentials&>(::_GrpcService_GoogleGrpc_SslCredentials_default_instance_);
}
inline const ::GrpcService_GoogleGrpc_SslCredentials& GrpcService_GoogleGrpc_ChannelCredentials::ssl_credentials() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.ChannelCredentials.ssl_credentials)
  return _internal_ssl_credentials();
}
inline ::GrpcService_GoogleGrpc_SslCredentials* GrpcService_GoogleGrpc_ChannelCredentials::unsafe_arena_release_ssl_credentials() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.ChannelCredentials.ssl_credentials)
  if (credential_specifier_case() == kSslCredentials) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.ssl_credentials_;
    _impl_.credential_specifier_.ssl_credentials_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::unsafe_arena_set_allocated_ssl_credentials(::GrpcService_GoogleGrpc_SslCredentials* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_credential_specifier();
  if (value) {
    set_has_ssl_credentials();
    _impl_.credential_specifier_.ssl_credentials_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.ChannelCredentials.ssl_credentials)
}
inline ::GrpcService_GoogleGrpc_SslCredentials* GrpcService_GoogleGrpc_ChannelCredentials::_internal_mutable_ssl_credentials() {
  if (credential_specifier_case() != kSslCredentials) {
    clear_credential_specifier();
    set_has_ssl_credentials();
    _impl_.credential_specifier_.ssl_credentials_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc_SslCredentials>(GetArena());
  }
  return _impl_.credential_specifier_.ssl_credentials_;
}
inline ::GrpcService_GoogleGrpc_SslCredentials* GrpcService_GoogleGrpc_ChannelCredentials::mutable_ssl_credentials() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_GoogleGrpc_SslCredentials* _msg = _internal_mutable_ssl_credentials();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.ChannelCredentials.ssl_credentials)
  return _msg;
}

// .GrpcService.GoogleGrpc.Empty google_default = 2;
inline bool GrpcService_GoogleGrpc_ChannelCredentials::has_google_default() const {
  return credential_specifier_case() == kGoogleDefault;
}
inline bool GrpcService_GoogleGrpc_ChannelCredentials::_internal_has_google_default() const {
  return credential_specifier_case() == kGoogleDefault;
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::set_has_google_default() {
  _impl_._oneof_case_[0] = kGoogleDefault;
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::clear_google_default() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kGoogleDefault) {
    if (GetArena() == nullptr) {
      delete _impl_.credential_specifier_.google_default_;
    }
    clear_has_credential_specifier();
  }
}
inline ::GrpcService_GoogleGrpc_Empty* GrpcService_GoogleGrpc_ChannelCredentials::release_google_default() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.ChannelCredentials.google_default)
  if (credential_specifier_case() == kGoogleDefault) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.google_default_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.credential_specifier_.google_default_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_GoogleGrpc_Empty& GrpcService_GoogleGrpc_ChannelCredentials::_internal_google_default() const {
  return credential_specifier_case() == kGoogleDefault ? *_impl_.credential_specifier_.google_default_ : reinterpret_cast<::GrpcService_GoogleGrpc_Empty&>(::_GrpcService_GoogleGrpc_Empty_default_instance_);
}
inline const ::GrpcService_GoogleGrpc_Empty& GrpcService_GoogleGrpc_ChannelCredentials::google_default() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.ChannelCredentials.google_default)
  return _internal_google_default();
}
inline ::GrpcService_GoogleGrpc_Empty* GrpcService_GoogleGrpc_ChannelCredentials::unsafe_arena_release_google_default() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.ChannelCredentials.google_default)
  if (credential_specifier_case() == kGoogleDefault) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.google_default_;
    _impl_.credential_specifier_.google_default_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::unsafe_arena_set_allocated_google_default(::GrpcService_GoogleGrpc_Empty* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_credential_specifier();
  if (value) {
    set_has_google_default();
    _impl_.credential_specifier_.google_default_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.ChannelCredentials.google_default)
}
inline ::GrpcService_GoogleGrpc_Empty* GrpcService_GoogleGrpc_ChannelCredentials::_internal_mutable_google_default() {
  if (credential_specifier_case() != kGoogleDefault) {
    clear_credential_specifier();
    set_has_google_default();
    _impl_.credential_specifier_.google_default_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc_Empty>(GetArena());
  }
  return _impl_.credential_specifier_.google_default_;
}
inline ::GrpcService_GoogleGrpc_Empty* GrpcService_GoogleGrpc_ChannelCredentials::mutable_google_default() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_GoogleGrpc_Empty* _msg = _internal_mutable_google_default();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.ChannelCredentials.google_default)
  return _msg;
}

// .GrpcService.GoogleGrpc.GoogleLocalCredentials local_credentials = 3;
inline bool GrpcService_GoogleGrpc_ChannelCredentials::has_local_credentials() const {
  return credential_specifier_case() == kLocalCredentials;
}
inline bool GrpcService_GoogleGrpc_ChannelCredentials::_internal_has_local_credentials() const {
  return credential_specifier_case() == kLocalCredentials;
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::set_has_local_credentials() {
  _impl_._oneof_case_[0] = kLocalCredentials;
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::clear_local_credentials() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kLocalCredentials) {
    if (GetArena() == nullptr) {
      delete _impl_.credential_specifier_.local_credentials_;
    }
    clear_has_credential_specifier();
  }
}
inline ::GrpcService_GoogleGrpc_GoogleLocalCredentials* GrpcService_GoogleGrpc_ChannelCredentials::release_local_credentials() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.ChannelCredentials.local_credentials)
  if (credential_specifier_case() == kLocalCredentials) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.local_credentials_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.credential_specifier_.local_credentials_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_GoogleGrpc_GoogleLocalCredentials& GrpcService_GoogleGrpc_ChannelCredentials::_internal_local_credentials() const {
  return credential_specifier_case() == kLocalCredentials ? *_impl_.credential_specifier_.local_credentials_ : reinterpret_cast<::GrpcService_GoogleGrpc_GoogleLocalCredentials&>(::_GrpcService_GoogleGrpc_GoogleLocalCredentials_default_instance_);
}
inline const ::GrpcService_GoogleGrpc_GoogleLocalCredentials& GrpcService_GoogleGrpc_ChannelCredentials::local_credentials() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.ChannelCredentials.local_credentials)
  return _internal_local_credentials();
}
inline ::GrpcService_GoogleGrpc_GoogleLocalCredentials* GrpcService_GoogleGrpc_ChannelCredentials::unsafe_arena_release_local_credentials() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.ChannelCredentials.local_credentials)
  if (credential_specifier_case() == kLocalCredentials) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.local_credentials_;
    _impl_.credential_specifier_.local_credentials_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::unsafe_arena_set_allocated_local_credentials(::GrpcService_GoogleGrpc_GoogleLocalCredentials* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_credential_specifier();
  if (value) {
    set_has_local_credentials();
    _impl_.credential_specifier_.local_credentials_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.ChannelCredentials.local_credentials)
}
inline ::GrpcService_GoogleGrpc_GoogleLocalCredentials* GrpcService_GoogleGrpc_ChannelCredentials::_internal_mutable_local_credentials() {
  if (credential_specifier_case() != kLocalCredentials) {
    clear_credential_specifier();
    set_has_local_credentials();
    _impl_.credential_specifier_.local_credentials_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc_GoogleLocalCredentials>(GetArena());
  }
  return _impl_.credential_specifier_.local_credentials_;
}
inline ::GrpcService_GoogleGrpc_GoogleLocalCredentials* GrpcService_GoogleGrpc_ChannelCredentials::mutable_local_credentials() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_GoogleGrpc_GoogleLocalCredentials* _msg = _internal_mutable_local_credentials();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.ChannelCredentials.local_credentials)
  return _msg;
}

inline bool GrpcService_GoogleGrpc_ChannelCredentials::has_credential_specifier() const {
  return credential_specifier_case() != CREDENTIAL_SPECIFIER_NOT_SET;
}
inline void GrpcService_GoogleGrpc_ChannelCredentials::clear_has_credential_specifier() {
  _impl_._oneof_case_[0] = CREDENTIAL_SPECIFIER_NOT_SET;
}
inline GrpcService_GoogleGrpc_ChannelCredentials::CredentialSpecifierCase GrpcService_GoogleGrpc_ChannelCredentials::credential_specifier_case() const {
  return GrpcService_GoogleGrpc_ChannelCredentials::CredentialSpecifierCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials

// string json_key = 1;
inline void GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::clear_json_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.json_key_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::json_key() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials.json_key)
  return _internal_json_key();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::set_json_key(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.json_key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials.json_key)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::mutable_json_key() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_json_key();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials.json_key)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::_internal_json_key() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.json_key_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::_internal_set_json_key(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.json_key_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::_internal_mutable_json_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.json_key_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::release_json_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials.json_key)
  return _impl_.json_key_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::set_allocated_json_key(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.json_key_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.json_key_.IsDefault()) {
          _impl_.json_key_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials.json_key)
}

// uint64 token_lifetime_seconds = 2;
inline void GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::clear_token_lifetime_seconds() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.token_lifetime_seconds_ = ::uint64_t{0u};
}
inline ::uint64_t GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::token_lifetime_seconds() const {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials.token_lifetime_seconds)
  return _internal_token_lifetime_seconds();
}
inline void GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::set_token_lifetime_seconds(::uint64_t value) {
  _internal_set_token_lifetime_seconds(value);
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials.token_lifetime_seconds)
}
inline ::uint64_t GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::_internal_token_lifetime_seconds() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.token_lifetime_seconds_;
}
inline void GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials::_internal_set_token_lifetime_seconds(::uint64_t value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.token_lifetime_seconds_ = value;
}

// -------------------------------------------------------------------

// GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials

// string authorization_token = 1;
inline void GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::clear_authorization_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.authorization_token_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::authorization_token() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authorization_token)
  return _internal_authorization_token();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::set_authorization_token(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.authorization_token_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authorization_token)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::mutable_authorization_token() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_authorization_token();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authorization_token)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::_internal_authorization_token() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.authorization_token_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::_internal_set_authorization_token(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.authorization_token_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::_internal_mutable_authorization_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.authorization_token_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::release_authorization_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authorization_token)
  return _impl_.authorization_token_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::set_allocated_authorization_token(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.authorization_token_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.authorization_token_.IsDefault()) {
          _impl_.authorization_token_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authorization_token)
}

// string authority_selector = 2;
inline void GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::clear_authority_selector() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.authority_selector_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::authority_selector() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authority_selector)
  return _internal_authority_selector();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::set_authority_selector(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.authority_selector_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authority_selector)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::mutable_authority_selector() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_authority_selector();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authority_selector)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::_internal_authority_selector() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.authority_selector_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::_internal_set_authority_selector(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.authority_selector_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::_internal_mutable_authority_selector() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.authority_selector_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::release_authority_selector() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authority_selector)
  return _impl_.authority_selector_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials::set_allocated_authority_selector(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.authority_selector_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.authority_selector_.IsDefault()) {
          _impl_.authority_selector_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials.authority_selector)
}

// -------------------------------------------------------------------

// GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin

// string name = 1;
inline void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::clear_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::set_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.name)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.name)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::_internal_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.name_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::_internal_set_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::_internal_mutable_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.name_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::release_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.name)
  return _impl_.name_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::set_allocated_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.name_.IsDefault()) {
          _impl_.name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.name)
}

// .google.protobuf.Struct config = 2 [deprecated = true];
inline bool GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::has_config() const {
  return config_type_case() == kConfig;
}
inline bool GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::_internal_has_config() const {
  return config_type_case() == kConfig;
}
inline void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::set_has_config() {
  _impl_._oneof_case_[0] = kConfig;
}
inline ::google::protobuf::Struct* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::release_config() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.config)
  if (config_type_case() == kConfig) {
    clear_has_config_type();
    auto* temp = _impl_.config_type_.config_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.config_type_.config_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::protobuf::Struct& GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::_internal_config() const {
  return config_type_case() == kConfig ? *_impl_.config_type_.config_ : reinterpret_cast<::google::protobuf::Struct&>(::google::protobuf::_Struct_default_instance_);
}
inline const ::google::protobuf::Struct& GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.config)
  return _internal_config();
}
inline ::google::protobuf::Struct* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::unsafe_arena_release_config() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.config)
  if (config_type_case() == kConfig) {
    clear_has_config_type();
    auto* temp = _impl_.config_type_.config_;
    _impl_.config_type_.config_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::unsafe_arena_set_allocated_config(::google::protobuf::Struct* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_config_type();
  if (value) {
    set_has_config();
    _impl_.config_type_.config_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.config)
}
inline ::google::protobuf::Struct* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::_internal_mutable_config() {
  if (config_type_case() != kConfig) {
    clear_config_type();
    set_has_config();
    _impl_.config_type_.config_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::google::protobuf::Struct>(GetArena());
  }
  return _impl_.config_type_.config_;
}
inline ::google::protobuf::Struct* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::mutable_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::Struct* _msg = _internal_mutable_config();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.config)
  return _msg;
}

// .Any typed_config = 3;
inline bool GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::has_typed_config() const {
  return config_type_case() == kTypedConfig;
}
inline bool GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::_internal_has_typed_config() const {
  return config_type_case() == kTypedConfig;
}
inline void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::set_has_typed_config() {
  _impl_._oneof_case_[0] = kTypedConfig;
}
inline void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::clear_typed_config() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (config_type_case() == kTypedConfig) {
    if (GetArena() == nullptr) {
      delete _impl_.config_type_.typed_config_;
    }
    clear_has_config_type();
  }
}
inline ::Any* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::release_typed_config() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.typed_config)
  if (config_type_case() == kTypedConfig) {
    clear_has_config_type();
    auto* temp = _impl_.config_type_.typed_config_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.config_type_.typed_config_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::Any& GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::_internal_typed_config() const {
  return config_type_case() == kTypedConfig ? *_impl_.config_type_.typed_config_ : reinterpret_cast<::Any&>(::_Any_default_instance_);
}
inline const ::Any& GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::typed_config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.typed_config)
  return _internal_typed_config();
}
inline ::Any* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::unsafe_arena_release_typed_config() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.typed_config)
  if (config_type_case() == kTypedConfig) {
    clear_has_config_type();
    auto* temp = _impl_.config_type_.typed_config_;
    _impl_.config_type_.typed_config_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::unsafe_arena_set_allocated_typed_config(::Any* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_config_type();
  if (value) {
    set_has_typed_config();
    _impl_.config_type_.typed_config_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.typed_config)
}
inline ::Any* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::_internal_mutable_typed_config() {
  if (config_type_case() != kTypedConfig) {
    clear_config_type();
    set_has_typed_config();
    _impl_.config_type_.typed_config_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::Any>(GetArena());
  }
  return _impl_.config_type_.typed_config_;
}
inline ::Any* GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::mutable_typed_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::Any* _msg = _internal_mutable_typed_config();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin.typed_config)
  return _msg;
}

inline bool GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::has_config_type() const {
  return config_type_case() != CONFIG_TYPE_NOT_SET;
}
inline void GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::clear_has_config_type() {
  _impl_._oneof_case_[0] = CONFIG_TYPE_NOT_SET;
}
inline GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::ConfigTypeCase GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::config_type_case() const {
  return GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin::ConfigTypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GrpcService_GoogleGrpc_CallCredentials_StsService

// string token_exchange_service_uri = 1;
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::clear_token_exchange_service_uri() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.token_exchange_service_uri_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::token_exchange_service_uri() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.StsService.token_exchange_service_uri)
  return _internal_token_exchange_service_uri();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_StsService::set_token_exchange_service_uri(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.token_exchange_service_uri_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.StsService.token_exchange_service_uri)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::mutable_token_exchange_service_uri() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_token_exchange_service_uri();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.StsService.token_exchange_service_uri)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_token_exchange_service_uri() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.token_exchange_service_uri_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_set_token_exchange_service_uri(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.token_exchange_service_uri_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_mutable_token_exchange_service_uri() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.token_exchange_service_uri_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::release_token_exchange_service_uri() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.StsService.token_exchange_service_uri)
  return _impl_.token_exchange_service_uri_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::set_allocated_token_exchange_service_uri(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.token_exchange_service_uri_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.token_exchange_service_uri_.IsDefault()) {
          _impl_.token_exchange_service_uri_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.StsService.token_exchange_service_uri)
}

// string resource = 2;
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::clear_resource() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resource_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::resource() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.StsService.resource)
  return _internal_resource();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_StsService::set_resource(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resource_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.StsService.resource)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::mutable_resource() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_resource();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.StsService.resource)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_resource() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.resource_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_set_resource(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resource_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_mutable_resource() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.resource_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::release_resource() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.StsService.resource)
  return _impl_.resource_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::set_allocated_resource(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.resource_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.resource_.IsDefault()) {
          _impl_.resource_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.StsService.resource)
}

// string audience = 3;
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::clear_audience() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.audience_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::audience() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.StsService.audience)
  return _internal_audience();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_StsService::set_audience(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.audience_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.StsService.audience)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::mutable_audience() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_audience();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.StsService.audience)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_audience() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.audience_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_set_audience(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.audience_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_mutable_audience() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.audience_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::release_audience() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.StsService.audience)
  return _impl_.audience_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::set_allocated_audience(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.audience_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.audience_.IsDefault()) {
          _impl_.audience_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.StsService.audience)
}

// string scope = 4;
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::clear_scope() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.scope_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::scope() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.StsService.scope)
  return _internal_scope();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_StsService::set_scope(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.scope_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.StsService.scope)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::mutable_scope() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_scope();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.StsService.scope)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_scope() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.scope_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_set_scope(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.scope_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_mutable_scope() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.scope_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::release_scope() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.StsService.scope)
  return _impl_.scope_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::set_allocated_scope(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.scope_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.scope_.IsDefault()) {
          _impl_.scope_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.StsService.scope)
}

// string requested_token_type = 5;
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::clear_requested_token_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.requested_token_type_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::requested_token_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.StsService.requested_token_type)
  return _internal_requested_token_type();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_StsService::set_requested_token_type(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.requested_token_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.StsService.requested_token_type)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::mutable_requested_token_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_requested_token_type();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.StsService.requested_token_type)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_requested_token_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.requested_token_type_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_set_requested_token_type(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.requested_token_type_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_mutable_requested_token_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.requested_token_type_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::release_requested_token_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.StsService.requested_token_type)
  return _impl_.requested_token_type_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::set_allocated_requested_token_type(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.requested_token_type_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.requested_token_type_.IsDefault()) {
          _impl_.requested_token_type_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.StsService.requested_token_type)
}

// string subject_token_path = 6;
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::clear_subject_token_path() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subject_token_path_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::subject_token_path() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_path)
  return _internal_subject_token_path();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_StsService::set_subject_token_path(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subject_token_path_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_path)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::mutable_subject_token_path() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_subject_token_path();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_path)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_subject_token_path() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.subject_token_path_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_set_subject_token_path(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subject_token_path_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_mutable_subject_token_path() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.subject_token_path_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::release_subject_token_path() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_path)
  return _impl_.subject_token_path_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::set_allocated_subject_token_path(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subject_token_path_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subject_token_path_.IsDefault()) {
          _impl_.subject_token_path_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_path)
}

// string subject_token_type = 7;
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::clear_subject_token_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subject_token_type_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::subject_token_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_type)
  return _internal_subject_token_type();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_StsService::set_subject_token_type(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subject_token_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_type)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::mutable_subject_token_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_subject_token_type();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_type)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_subject_token_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.subject_token_type_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_set_subject_token_type(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subject_token_type_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_mutable_subject_token_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.subject_token_type_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::release_subject_token_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_type)
  return _impl_.subject_token_type_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::set_allocated_subject_token_type(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.subject_token_type_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.subject_token_type_.IsDefault()) {
          _impl_.subject_token_type_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.StsService.subject_token_type)
}

// string actor_token_path = 8;
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::clear_actor_token_path() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actor_token_path_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::actor_token_path() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_path)
  return _internal_actor_token_path();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_StsService::set_actor_token_path(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actor_token_path_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_path)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::mutable_actor_token_path() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_actor_token_path();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_path)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_actor_token_path() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.actor_token_path_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_set_actor_token_path(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actor_token_path_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_mutable_actor_token_path() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.actor_token_path_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::release_actor_token_path() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_path)
  return _impl_.actor_token_path_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::set_allocated_actor_token_path(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actor_token_path_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.actor_token_path_.IsDefault()) {
          _impl_.actor_token_path_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_path)
}

// string actor_token_type = 9;
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::clear_actor_token_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actor_token_type_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::actor_token_type() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_type)
  return _internal_actor_token_type();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials_StsService::set_actor_token_type(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actor_token_type_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_type)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::mutable_actor_token_type() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_actor_token_type();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_type)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_actor_token_type() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.actor_token_type_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_set_actor_token_type(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actor_token_type_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::_internal_mutable_actor_token_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.actor_token_type_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials_StsService::release_actor_token_type() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_type)
  return _impl_.actor_token_type_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials_StsService::set_allocated_actor_token_type(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.actor_token_type_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.actor_token_type_.IsDefault()) {
          _impl_.actor_token_type_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.StsService.actor_token_type)
}

// -------------------------------------------------------------------

// GrpcService_GoogleGrpc_CallCredentials

// string access_token = 1;
inline bool GrpcService_GoogleGrpc_CallCredentials::has_access_token() const {
  return credential_specifier_case() == kAccessToken;
}
inline void GrpcService_GoogleGrpc_CallCredentials::set_has_access_token() {
  _impl_._oneof_case_[0] = kAccessToken;
}
inline void GrpcService_GoogleGrpc_CallCredentials::clear_access_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kAccessToken) {
    _impl_.credential_specifier_.access_token_.Destroy();
    clear_has_credential_specifier();
  }
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials::access_token() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.access_token)
  return _internal_access_token();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials::set_access_token(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() != kAccessToken) {
    clear_credential_specifier();

    set_has_access_token();
    _impl_.credential_specifier_.access_token_.InitDefault();
  }
  _impl_.credential_specifier_.access_token_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.access_token)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials::mutable_access_token() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_access_token();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.access_token)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials::_internal_access_token() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  if (credential_specifier_case() != kAccessToken) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.credential_specifier_.access_token_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials::_internal_set_access_token(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() != kAccessToken) {
    clear_credential_specifier();

    set_has_access_token();
    _impl_.credential_specifier_.access_token_.InitDefault();
  }
  _impl_.credential_specifier_.access_token_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials::_internal_mutable_access_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() != kAccessToken) {
    clear_credential_specifier();

    set_has_access_token();
    _impl_.credential_specifier_.access_token_.InitDefault();
  }
  return _impl_.credential_specifier_.access_token_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials::release_access_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.access_token)
  if (credential_specifier_case() != kAccessToken) {
    return nullptr;
  }
  clear_has_credential_specifier();
  return _impl_.credential_specifier_.access_token_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials::set_allocated_access_token(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (has_credential_specifier()) {
    clear_credential_specifier();
  }
  if (value != nullptr) {
    set_has_access_token();
    _impl_.credential_specifier_.access_token_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.access_token)
}

// .GrpcService.GoogleGrpc.Empty google_compute_engine = 2;
inline bool GrpcService_GoogleGrpc_CallCredentials::has_google_compute_engine() const {
  return credential_specifier_case() == kGoogleComputeEngine;
}
inline bool GrpcService_GoogleGrpc_CallCredentials::_internal_has_google_compute_engine() const {
  return credential_specifier_case() == kGoogleComputeEngine;
}
inline void GrpcService_GoogleGrpc_CallCredentials::set_has_google_compute_engine() {
  _impl_._oneof_case_[0] = kGoogleComputeEngine;
}
inline void GrpcService_GoogleGrpc_CallCredentials::clear_google_compute_engine() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kGoogleComputeEngine) {
    if (GetArena() == nullptr) {
      delete _impl_.credential_specifier_.google_compute_engine_;
    }
    clear_has_credential_specifier();
  }
}
inline ::GrpcService_GoogleGrpc_Empty* GrpcService_GoogleGrpc_CallCredentials::release_google_compute_engine() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.google_compute_engine)
  if (credential_specifier_case() == kGoogleComputeEngine) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.google_compute_engine_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.credential_specifier_.google_compute_engine_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_GoogleGrpc_Empty& GrpcService_GoogleGrpc_CallCredentials::_internal_google_compute_engine() const {
  return credential_specifier_case() == kGoogleComputeEngine ? *_impl_.credential_specifier_.google_compute_engine_ : reinterpret_cast<::GrpcService_GoogleGrpc_Empty&>(::_GrpcService_GoogleGrpc_Empty_default_instance_);
}
inline const ::GrpcService_GoogleGrpc_Empty& GrpcService_GoogleGrpc_CallCredentials::google_compute_engine() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.google_compute_engine)
  return _internal_google_compute_engine();
}
inline ::GrpcService_GoogleGrpc_Empty* GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_release_google_compute_engine() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.CallCredentials.google_compute_engine)
  if (credential_specifier_case() == kGoogleComputeEngine) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.google_compute_engine_;
    _impl_.credential_specifier_.google_compute_engine_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_set_allocated_google_compute_engine(::GrpcService_GoogleGrpc_Empty* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_credential_specifier();
  if (value) {
    set_has_google_compute_engine();
    _impl_.credential_specifier_.google_compute_engine_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.CallCredentials.google_compute_engine)
}
inline ::GrpcService_GoogleGrpc_Empty* GrpcService_GoogleGrpc_CallCredentials::_internal_mutable_google_compute_engine() {
  if (credential_specifier_case() != kGoogleComputeEngine) {
    clear_credential_specifier();
    set_has_google_compute_engine();
    _impl_.credential_specifier_.google_compute_engine_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc_Empty>(GetArena());
  }
  return _impl_.credential_specifier_.google_compute_engine_;
}
inline ::GrpcService_GoogleGrpc_Empty* GrpcService_GoogleGrpc_CallCredentials::mutable_google_compute_engine() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_GoogleGrpc_Empty* _msg = _internal_mutable_google_compute_engine();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.google_compute_engine)
  return _msg;
}

// string google_refresh_token = 3;
inline bool GrpcService_GoogleGrpc_CallCredentials::has_google_refresh_token() const {
  return credential_specifier_case() == kGoogleRefreshToken;
}
inline void GrpcService_GoogleGrpc_CallCredentials::set_has_google_refresh_token() {
  _impl_._oneof_case_[0] = kGoogleRefreshToken;
}
inline void GrpcService_GoogleGrpc_CallCredentials::clear_google_refresh_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kGoogleRefreshToken) {
    _impl_.credential_specifier_.google_refresh_token_.Destroy();
    clear_has_credential_specifier();
  }
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials::google_refresh_token() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.google_refresh_token)
  return _internal_google_refresh_token();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc_CallCredentials::set_google_refresh_token(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() != kGoogleRefreshToken) {
    clear_credential_specifier();

    set_has_google_refresh_token();
    _impl_.credential_specifier_.google_refresh_token_.InitDefault();
  }
  _impl_.credential_specifier_.google_refresh_token_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.CallCredentials.google_refresh_token)
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials::mutable_google_refresh_token() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_google_refresh_token();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.google_refresh_token)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc_CallCredentials::_internal_google_refresh_token() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  if (credential_specifier_case() != kGoogleRefreshToken) {
    return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
  }
  return _impl_.credential_specifier_.google_refresh_token_.Get();
}
inline void GrpcService_GoogleGrpc_CallCredentials::_internal_set_google_refresh_token(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() != kGoogleRefreshToken) {
    clear_credential_specifier();

    set_has_google_refresh_token();
    _impl_.credential_specifier_.google_refresh_token_.InitDefault();
  }
  _impl_.credential_specifier_.google_refresh_token_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials::_internal_mutable_google_refresh_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() != kGoogleRefreshToken) {
    clear_credential_specifier();

    set_has_google_refresh_token();
    _impl_.credential_specifier_.google_refresh_token_.InitDefault();
  }
  return _impl_.credential_specifier_.google_refresh_token_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc_CallCredentials::release_google_refresh_token() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.google_refresh_token)
  if (credential_specifier_case() != kGoogleRefreshToken) {
    return nullptr;
  }
  clear_has_credential_specifier();
  return _impl_.credential_specifier_.google_refresh_token_.Release();
}
inline void GrpcService_GoogleGrpc_CallCredentials::set_allocated_google_refresh_token(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (has_credential_specifier()) {
    clear_credential_specifier();
  }
  if (value != nullptr) {
    set_has_google_refresh_token();
    _impl_.credential_specifier_.google_refresh_token_.InitAllocated(value, GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.CallCredentials.google_refresh_token)
}

// .GrpcService.GoogleGrpc.CallCredentials.ServiceAccountJWTAccessCredentials service_account_jwt_access = 4;
inline bool GrpcService_GoogleGrpc_CallCredentials::has_service_account_jwt_access() const {
  return credential_specifier_case() == kServiceAccountJwtAccess;
}
inline bool GrpcService_GoogleGrpc_CallCredentials::_internal_has_service_account_jwt_access() const {
  return credential_specifier_case() == kServiceAccountJwtAccess;
}
inline void GrpcService_GoogleGrpc_CallCredentials::set_has_service_account_jwt_access() {
  _impl_._oneof_case_[0] = kServiceAccountJwtAccess;
}
inline void GrpcService_GoogleGrpc_CallCredentials::clear_service_account_jwt_access() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kServiceAccountJwtAccess) {
    if (GetArena() == nullptr) {
      delete _impl_.credential_specifier_.service_account_jwt_access_;
    }
    clear_has_credential_specifier();
  }
}
inline ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* GrpcService_GoogleGrpc_CallCredentials::release_service_account_jwt_access() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.service_account_jwt_access)
  if (credential_specifier_case() == kServiceAccountJwtAccess) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.service_account_jwt_access_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.credential_specifier_.service_account_jwt_access_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& GrpcService_GoogleGrpc_CallCredentials::_internal_service_account_jwt_access() const {
  return credential_specifier_case() == kServiceAccountJwtAccess ? *_impl_.credential_specifier_.service_account_jwt_access_ : reinterpret_cast<::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials&>(::_GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials_default_instance_);
}
inline const ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials& GrpcService_GoogleGrpc_CallCredentials::service_account_jwt_access() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.service_account_jwt_access)
  return _internal_service_account_jwt_access();
}
inline ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_release_service_account_jwt_access() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.CallCredentials.service_account_jwt_access)
  if (credential_specifier_case() == kServiceAccountJwtAccess) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.service_account_jwt_access_;
    _impl_.credential_specifier_.service_account_jwt_access_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_set_allocated_service_account_jwt_access(::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_credential_specifier();
  if (value) {
    set_has_service_account_jwt_access();
    _impl_.credential_specifier_.service_account_jwt_access_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.CallCredentials.service_account_jwt_access)
}
inline ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* GrpcService_GoogleGrpc_CallCredentials::_internal_mutable_service_account_jwt_access() {
  if (credential_specifier_case() != kServiceAccountJwtAccess) {
    clear_credential_specifier();
    set_has_service_account_jwt_access();
    _impl_.credential_specifier_.service_account_jwt_access_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials>(GetArena());
  }
  return _impl_.credential_specifier_.service_account_jwt_access_;
}
inline ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* GrpcService_GoogleGrpc_CallCredentials::mutable_service_account_jwt_access() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_GoogleGrpc_CallCredentials_ServiceAccountJWTAccessCredentials* _msg = _internal_mutable_service_account_jwt_access();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.service_account_jwt_access)
  return _msg;
}

// .GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials google_iam = 5;
inline bool GrpcService_GoogleGrpc_CallCredentials::has_google_iam() const {
  return credential_specifier_case() == kGoogleIam;
}
inline bool GrpcService_GoogleGrpc_CallCredentials::_internal_has_google_iam() const {
  return credential_specifier_case() == kGoogleIam;
}
inline void GrpcService_GoogleGrpc_CallCredentials::set_has_google_iam() {
  _impl_._oneof_case_[0] = kGoogleIam;
}
inline void GrpcService_GoogleGrpc_CallCredentials::clear_google_iam() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kGoogleIam) {
    if (GetArena() == nullptr) {
      delete _impl_.credential_specifier_.google_iam_;
    }
    clear_has_credential_specifier();
  }
}
inline ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* GrpcService_GoogleGrpc_CallCredentials::release_google_iam() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.google_iam)
  if (credential_specifier_case() == kGoogleIam) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.google_iam_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.credential_specifier_.google_iam_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& GrpcService_GoogleGrpc_CallCredentials::_internal_google_iam() const {
  return credential_specifier_case() == kGoogleIam ? *_impl_.credential_specifier_.google_iam_ : reinterpret_cast<::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials&>(::_GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials_default_instance_);
}
inline const ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials& GrpcService_GoogleGrpc_CallCredentials::google_iam() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.google_iam)
  return _internal_google_iam();
}
inline ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_release_google_iam() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.CallCredentials.google_iam)
  if (credential_specifier_case() == kGoogleIam) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.google_iam_;
    _impl_.credential_specifier_.google_iam_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_set_allocated_google_iam(::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_credential_specifier();
  if (value) {
    set_has_google_iam();
    _impl_.credential_specifier_.google_iam_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.CallCredentials.google_iam)
}
inline ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* GrpcService_GoogleGrpc_CallCredentials::_internal_mutable_google_iam() {
  if (credential_specifier_case() != kGoogleIam) {
    clear_credential_specifier();
    set_has_google_iam();
    _impl_.credential_specifier_.google_iam_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials>(GetArena());
  }
  return _impl_.credential_specifier_.google_iam_;
}
inline ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* GrpcService_GoogleGrpc_CallCredentials::mutable_google_iam() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_GoogleGrpc_CallCredentials_GoogleIAMCredentials* _msg = _internal_mutable_google_iam();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.google_iam)
  return _msg;
}

// .GrpcService.GoogleGrpc.CallCredentials.MetadataCredentialsFromPlugin from_plugin = 6;
inline bool GrpcService_GoogleGrpc_CallCredentials::has_from_plugin() const {
  return credential_specifier_case() == kFromPlugin;
}
inline bool GrpcService_GoogleGrpc_CallCredentials::_internal_has_from_plugin() const {
  return credential_specifier_case() == kFromPlugin;
}
inline void GrpcService_GoogleGrpc_CallCredentials::set_has_from_plugin() {
  _impl_._oneof_case_[0] = kFromPlugin;
}
inline void GrpcService_GoogleGrpc_CallCredentials::clear_from_plugin() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kFromPlugin) {
    if (GetArena() == nullptr) {
      delete _impl_.credential_specifier_.from_plugin_;
    }
    clear_has_credential_specifier();
  }
}
inline ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* GrpcService_GoogleGrpc_CallCredentials::release_from_plugin() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.from_plugin)
  if (credential_specifier_case() == kFromPlugin) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.from_plugin_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.credential_specifier_.from_plugin_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& GrpcService_GoogleGrpc_CallCredentials::_internal_from_plugin() const {
  return credential_specifier_case() == kFromPlugin ? *_impl_.credential_specifier_.from_plugin_ : reinterpret_cast<::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin&>(::_GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin_default_instance_);
}
inline const ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin& GrpcService_GoogleGrpc_CallCredentials::from_plugin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.from_plugin)
  return _internal_from_plugin();
}
inline ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_release_from_plugin() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.CallCredentials.from_plugin)
  if (credential_specifier_case() == kFromPlugin) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.from_plugin_;
    _impl_.credential_specifier_.from_plugin_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_set_allocated_from_plugin(::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_credential_specifier();
  if (value) {
    set_has_from_plugin();
    _impl_.credential_specifier_.from_plugin_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.CallCredentials.from_plugin)
}
inline ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* GrpcService_GoogleGrpc_CallCredentials::_internal_mutable_from_plugin() {
  if (credential_specifier_case() != kFromPlugin) {
    clear_credential_specifier();
    set_has_from_plugin();
    _impl_.credential_specifier_.from_plugin_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin>(GetArena());
  }
  return _impl_.credential_specifier_.from_plugin_;
}
inline ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* GrpcService_GoogleGrpc_CallCredentials::mutable_from_plugin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_GoogleGrpc_CallCredentials_MetadataCredentialsFromPlugin* _msg = _internal_mutable_from_plugin();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.from_plugin)
  return _msg;
}

// .GrpcService.GoogleGrpc.CallCredentials.StsService sts_service = 7;
inline bool GrpcService_GoogleGrpc_CallCredentials::has_sts_service() const {
  return credential_specifier_case() == kStsService;
}
inline bool GrpcService_GoogleGrpc_CallCredentials::_internal_has_sts_service() const {
  return credential_specifier_case() == kStsService;
}
inline void GrpcService_GoogleGrpc_CallCredentials::set_has_sts_service() {
  _impl_._oneof_case_[0] = kStsService;
}
inline void GrpcService_GoogleGrpc_CallCredentials::clear_sts_service() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (credential_specifier_case() == kStsService) {
    if (GetArena() == nullptr) {
      delete _impl_.credential_specifier_.sts_service_;
    }
    clear_has_credential_specifier();
  }
}
inline ::GrpcService_GoogleGrpc_CallCredentials_StsService* GrpcService_GoogleGrpc_CallCredentials::release_sts_service() {
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.CallCredentials.sts_service)
  if (credential_specifier_case() == kStsService) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.sts_service_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.credential_specifier_.sts_service_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_GoogleGrpc_CallCredentials_StsService& GrpcService_GoogleGrpc_CallCredentials::_internal_sts_service() const {
  return credential_specifier_case() == kStsService ? *_impl_.credential_specifier_.sts_service_ : reinterpret_cast<::GrpcService_GoogleGrpc_CallCredentials_StsService&>(::_GrpcService_GoogleGrpc_CallCredentials_StsService_default_instance_);
}
inline const ::GrpcService_GoogleGrpc_CallCredentials_StsService& GrpcService_GoogleGrpc_CallCredentials::sts_service() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.CallCredentials.sts_service)
  return _internal_sts_service();
}
inline ::GrpcService_GoogleGrpc_CallCredentials_StsService* GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_release_sts_service() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.GoogleGrpc.CallCredentials.sts_service)
  if (credential_specifier_case() == kStsService) {
    clear_has_credential_specifier();
    auto* temp = _impl_.credential_specifier_.sts_service_;
    _impl_.credential_specifier_.sts_service_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService_GoogleGrpc_CallCredentials::unsafe_arena_set_allocated_sts_service(::GrpcService_GoogleGrpc_CallCredentials_StsService* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_credential_specifier();
  if (value) {
    set_has_sts_service();
    _impl_.credential_specifier_.sts_service_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.CallCredentials.sts_service)
}
inline ::GrpcService_GoogleGrpc_CallCredentials_StsService* GrpcService_GoogleGrpc_CallCredentials::_internal_mutable_sts_service() {
  if (credential_specifier_case() != kStsService) {
    clear_credential_specifier();
    set_has_sts_service();
    _impl_.credential_specifier_.sts_service_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc_CallCredentials_StsService>(GetArena());
  }
  return _impl_.credential_specifier_.sts_service_;
}
inline ::GrpcService_GoogleGrpc_CallCredentials_StsService* GrpcService_GoogleGrpc_CallCredentials::mutable_sts_service() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_GoogleGrpc_CallCredentials_StsService* _msg = _internal_mutable_sts_service();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.CallCredentials.sts_service)
  return _msg;
}

inline bool GrpcService_GoogleGrpc_CallCredentials::has_credential_specifier() const {
  return credential_specifier_case() != CREDENTIAL_SPECIFIER_NOT_SET;
}
inline void GrpcService_GoogleGrpc_CallCredentials::clear_has_credential_specifier() {
  _impl_._oneof_case_[0] = CREDENTIAL_SPECIFIER_NOT_SET;
}
inline GrpcService_GoogleGrpc_CallCredentials::CredentialSpecifierCase GrpcService_GoogleGrpc_CallCredentials::credential_specifier_case() const {
  return GrpcService_GoogleGrpc_CallCredentials::CredentialSpecifierCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// GrpcService_GoogleGrpc

// string target_uri = 1;
inline void GrpcService_GoogleGrpc::clear_target_uri() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_uri_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc::target_uri() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.target_uri)
  return _internal_target_uri();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc::set_target_uri(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_uri_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.target_uri)
}
inline std::string* GrpcService_GoogleGrpc::mutable_target_uri() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_target_uri();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.target_uri)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc::_internal_target_uri() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.target_uri_.Get();
}
inline void GrpcService_GoogleGrpc::_internal_set_target_uri(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_uri_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc::_internal_mutable_target_uri() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.target_uri_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc::release_target_uri() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.target_uri)
  return _impl_.target_uri_.Release();
}
inline void GrpcService_GoogleGrpc::set_allocated_target_uri(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.target_uri_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.target_uri_.IsDefault()) {
          _impl_.target_uri_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.target_uri)
}

// .GrpcService.GoogleGrpc.ChannelCredentials channel_credentials = 2;
inline bool GrpcService_GoogleGrpc::has_channel_credentials() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.channel_credentials_ != nullptr);
  return value;
}
inline void GrpcService_GoogleGrpc::clear_channel_credentials() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.channel_credentials_ != nullptr) _impl_.channel_credentials_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::GrpcService_GoogleGrpc_ChannelCredentials& GrpcService_GoogleGrpc::_internal_channel_credentials() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::GrpcService_GoogleGrpc_ChannelCredentials* p = _impl_.channel_credentials_;
  return p != nullptr ? *p : reinterpret_cast<const ::GrpcService_GoogleGrpc_ChannelCredentials&>(::_GrpcService_GoogleGrpc_ChannelCredentials_default_instance_);
}
inline const ::GrpcService_GoogleGrpc_ChannelCredentials& GrpcService_GoogleGrpc::channel_credentials() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.channel_credentials)
  return _internal_channel_credentials();
}
inline void GrpcService_GoogleGrpc::unsafe_arena_set_allocated_channel_credentials(::GrpcService_GoogleGrpc_ChannelCredentials* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.channel_credentials_);
  }
  _impl_.channel_credentials_ = reinterpret_cast<::GrpcService_GoogleGrpc_ChannelCredentials*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.channel_credentials)
}
inline ::GrpcService_GoogleGrpc_ChannelCredentials* GrpcService_GoogleGrpc::release_channel_credentials() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::GrpcService_GoogleGrpc_ChannelCredentials* released = _impl_.channel_credentials_;
  _impl_.channel_credentials_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::GrpcService_GoogleGrpc_ChannelCredentials* GrpcService_GoogleGrpc::unsafe_arena_release_channel_credentials() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.channel_credentials)

  _impl_._has_bits_[0] &= ~0x00000001u;
  ::GrpcService_GoogleGrpc_ChannelCredentials* temp = _impl_.channel_credentials_;
  _impl_.channel_credentials_ = nullptr;
  return temp;
}
inline ::GrpcService_GoogleGrpc_ChannelCredentials* GrpcService_GoogleGrpc::_internal_mutable_channel_credentials() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.channel_credentials_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc_ChannelCredentials>(GetArena());
    _impl_.channel_credentials_ = reinterpret_cast<::GrpcService_GoogleGrpc_ChannelCredentials*>(p);
  }
  return _impl_.channel_credentials_;
}
inline ::GrpcService_GoogleGrpc_ChannelCredentials* GrpcService_GoogleGrpc::mutable_channel_credentials() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000001u;
  ::GrpcService_GoogleGrpc_ChannelCredentials* _msg = _internal_mutable_channel_credentials();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.channel_credentials)
  return _msg;
}
inline void GrpcService_GoogleGrpc::set_allocated_channel_credentials(::GrpcService_GoogleGrpc_ChannelCredentials* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete (_impl_.channel_credentials_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = (value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }

  _impl_.channel_credentials_ = reinterpret_cast<::GrpcService_GoogleGrpc_ChannelCredentials*>(value);
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.channel_credentials)
}

// repeated .GrpcService.GoogleGrpc.CallCredentials call_credentials = 3;
inline int GrpcService_GoogleGrpc::_internal_call_credentials_size() const {
  return _internal_call_credentials().size();
}
inline int GrpcService_GoogleGrpc::call_credentials_size() const {
  return _internal_call_credentials_size();
}
inline void GrpcService_GoogleGrpc::clear_call_credentials() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.call_credentials_.Clear();
}
inline ::GrpcService_GoogleGrpc_CallCredentials* GrpcService_GoogleGrpc::mutable_call_credentials(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.call_credentials)
  return _internal_mutable_call_credentials()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::GrpcService_GoogleGrpc_CallCredentials>* GrpcService_GoogleGrpc::mutable_call_credentials()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:GrpcService.GoogleGrpc.call_credentials)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_call_credentials();
}
inline const ::GrpcService_GoogleGrpc_CallCredentials& GrpcService_GoogleGrpc::call_credentials(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.call_credentials)
  return _internal_call_credentials().Get(index);
}
inline ::GrpcService_GoogleGrpc_CallCredentials* GrpcService_GoogleGrpc::add_call_credentials() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::GrpcService_GoogleGrpc_CallCredentials* _add = _internal_mutable_call_credentials()->Add();
  // @@protoc_insertion_point(field_add:GrpcService.GoogleGrpc.call_credentials)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::GrpcService_GoogleGrpc_CallCredentials>& GrpcService_GoogleGrpc::call_credentials() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:GrpcService.GoogleGrpc.call_credentials)
  return _internal_call_credentials();
}
inline const ::google::protobuf::RepeatedPtrField<::GrpcService_GoogleGrpc_CallCredentials>&
GrpcService_GoogleGrpc::_internal_call_credentials() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.call_credentials_;
}
inline ::google::protobuf::RepeatedPtrField<::GrpcService_GoogleGrpc_CallCredentials>*
GrpcService_GoogleGrpc::_internal_mutable_call_credentials() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.call_credentials_;
}

// string stat_prefix = 4;
inline void GrpcService_GoogleGrpc::clear_stat_prefix() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stat_prefix_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc::stat_prefix() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.stat_prefix)
  return _internal_stat_prefix();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc::set_stat_prefix(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stat_prefix_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.stat_prefix)
}
inline std::string* GrpcService_GoogleGrpc::mutable_stat_prefix() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_stat_prefix();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.stat_prefix)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc::_internal_stat_prefix() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.stat_prefix_.Get();
}
inline void GrpcService_GoogleGrpc::_internal_set_stat_prefix(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stat_prefix_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc::_internal_mutable_stat_prefix() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.stat_prefix_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc::release_stat_prefix() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.stat_prefix)
  return _impl_.stat_prefix_.Release();
}
inline void GrpcService_GoogleGrpc::set_allocated_stat_prefix(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.stat_prefix_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.stat_prefix_.IsDefault()) {
          _impl_.stat_prefix_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.stat_prefix)
}

// string credentials_factory_name = 5;
inline void GrpcService_GoogleGrpc::clear_credentials_factory_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.credentials_factory_name_.ClearToEmpty();
}
inline const std::string& GrpcService_GoogleGrpc::credentials_factory_name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.credentials_factory_name)
  return _internal_credentials_factory_name();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_GoogleGrpc::set_credentials_factory_name(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.credentials_factory_name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.GoogleGrpc.credentials_factory_name)
}
inline std::string* GrpcService_GoogleGrpc::mutable_credentials_factory_name() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_credentials_factory_name();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.credentials_factory_name)
  return _s;
}
inline const std::string& GrpcService_GoogleGrpc::_internal_credentials_factory_name() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.credentials_factory_name_.Get();
}
inline void GrpcService_GoogleGrpc::_internal_set_credentials_factory_name(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.credentials_factory_name_.Set(value, GetArena());
}
inline std::string* GrpcService_GoogleGrpc::_internal_mutable_credentials_factory_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.credentials_factory_name_.Mutable( GetArena());
}
inline std::string* GrpcService_GoogleGrpc::release_credentials_factory_name() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.credentials_factory_name)
  return _impl_.credentials_factory_name_.Release();
}
inline void GrpcService_GoogleGrpc::set_allocated_credentials_factory_name(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.credentials_factory_name_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.credentials_factory_name_.IsDefault()) {
          _impl_.credentials_factory_name_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.credentials_factory_name)
}

// .google.protobuf.Struct config = 6;
inline bool GrpcService_GoogleGrpc::has_config() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.config_ != nullptr);
  return value;
}
inline const ::google::protobuf::Struct& GrpcService_GoogleGrpc::_internal_config() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  const ::google::protobuf::Struct* p = _impl_.config_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::protobuf::Struct&>(::google::protobuf::_Struct_default_instance_);
}
inline const ::google::protobuf::Struct& GrpcService_GoogleGrpc::config() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.GoogleGrpc.config)
  return _internal_config();
}
inline void GrpcService_GoogleGrpc::unsafe_arena_set_allocated_config(::google::protobuf::Struct* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.config_);
  }
  _impl_.config_ = reinterpret_cast<::google::protobuf::Struct*>(value);
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.GoogleGrpc.config)
}
inline ::google::protobuf::Struct* GrpcService_GoogleGrpc::release_config() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::google::protobuf::Struct* released = _impl_.config_;
  _impl_.config_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
  released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  if (GetArena() == nullptr) {
    delete old;
  }
#else   // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArena() != nullptr) {
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return released;
}
inline ::google::protobuf::Struct* GrpcService_GoogleGrpc::unsafe_arena_release_config() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.GoogleGrpc.config)

  _impl_._has_bits_[0] &= ~0x00000002u;
  ::google::protobuf::Struct* temp = _impl_.config_;
  _impl_.config_ = nullptr;
  return temp;
}
inline ::google::protobuf::Struct* GrpcService_GoogleGrpc::_internal_mutable_config() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.config_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::google::protobuf::Struct>(GetArena());
    _impl_.config_ = reinterpret_cast<::google::protobuf::Struct*>(p);
  }
  return _impl_.config_;
}
inline ::google::protobuf::Struct* GrpcService_GoogleGrpc::mutable_config() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  _impl_._has_bits_[0] |= 0x00000002u;
  ::google::protobuf::Struct* _msg = _internal_mutable_config();
  // @@protoc_insertion_point(field_mutable:GrpcService.GoogleGrpc.config)
  return _msg;
}
inline void GrpcService_GoogleGrpc::set_allocated_config(::google::protobuf::Struct* value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.config_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }

  _impl_.config_ = reinterpret_cast<::google::protobuf::Struct*>(value);
  // @@protoc_insertion_point(field_set_allocated:GrpcService.GoogleGrpc.config)
}

// -------------------------------------------------------------------

// GrpcService_HeaderValue

// string key = 1;
inline void GrpcService_HeaderValue::clear_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.ClearToEmpty();
}
inline const std::string& GrpcService_HeaderValue::key() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.HeaderValue.key)
  return _internal_key();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_HeaderValue::set_key(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.HeaderValue.key)
}
inline std::string* GrpcService_HeaderValue::mutable_key() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:GrpcService.HeaderValue.key)
  return _s;
}
inline const std::string& GrpcService_HeaderValue::_internal_key() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.key_.Get();
}
inline void GrpcService_HeaderValue::_internal_set_key(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.Set(value, GetArena());
}
inline std::string* GrpcService_HeaderValue::_internal_mutable_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.key_.Mutable( GetArena());
}
inline std::string* GrpcService_HeaderValue::release_key() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.HeaderValue.key)
  return _impl_.key_.Release();
}
inline void GrpcService_HeaderValue::set_allocated_key(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.key_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.key_.IsDefault()) {
          _impl_.key_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.HeaderValue.key)
}

// string value = 2;
inline void GrpcService_HeaderValue::clear_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.value_.ClearToEmpty();
}
inline const std::string& GrpcService_HeaderValue::value() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.HeaderValue.value)
  return _internal_value();
}
template <typename Arg_, typename... Args_>
inline PROTOBUF_ALWAYS_INLINE void GrpcService_HeaderValue::set_value(Arg_&& arg,
                                                     Args_... args) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.value_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:GrpcService.HeaderValue.value)
}
inline std::string* GrpcService_HeaderValue::mutable_value() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:GrpcService.HeaderValue.value)
  return _s;
}
inline const std::string& GrpcService_HeaderValue::_internal_value() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.value_.Get();
}
inline void GrpcService_HeaderValue::_internal_set_value(const std::string& value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.value_.Set(value, GetArena());
}
inline std::string* GrpcService_HeaderValue::_internal_mutable_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _impl_.value_.Mutable( GetArena());
}
inline std::string* GrpcService_HeaderValue::release_value() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  // @@protoc_insertion_point(field_release:GrpcService.HeaderValue.value)
  return _impl_.value_.Release();
}
inline void GrpcService_HeaderValue::set_allocated_value(std::string* value) {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.value_.SetAllocated(value, GetArena());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        if (_impl_.value_.IsDefault()) {
          _impl_.value_.Set("", GetArena());
        }
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:GrpcService.HeaderValue.value)
}

// -------------------------------------------------------------------

// GrpcService

// .GrpcService.EnvoyGrpc envoy_grpc = 1;
inline bool GrpcService::has_envoy_grpc() const {
  return target_specifier_case() == kEnvoyGrpc;
}
inline bool GrpcService::_internal_has_envoy_grpc() const {
  return target_specifier_case() == kEnvoyGrpc;
}
inline void GrpcService::set_has_envoy_grpc() {
  _impl_._oneof_case_[0] = kEnvoyGrpc;
}
inline void GrpcService::clear_envoy_grpc() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (target_specifier_case() == kEnvoyGrpc) {
    if (GetArena() == nullptr) {
      delete _impl_.target_specifier_.envoy_grpc_;
    }
    clear_has_target_specifier();
  }
}
inline ::GrpcService_EnvoyGrpc* GrpcService::release_envoy_grpc() {
  // @@protoc_insertion_point(field_release:GrpcService.envoy_grpc)
  if (target_specifier_case() == kEnvoyGrpc) {
    clear_has_target_specifier();
    auto* temp = _impl_.target_specifier_.envoy_grpc_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.target_specifier_.envoy_grpc_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_EnvoyGrpc& GrpcService::_internal_envoy_grpc() const {
  return target_specifier_case() == kEnvoyGrpc ? *_impl_.target_specifier_.envoy_grpc_ : reinterpret_cast<::GrpcService_EnvoyGrpc&>(::_GrpcService_EnvoyGrpc_default_instance_);
}
inline const ::GrpcService_EnvoyGrpc& GrpcService::envoy_grpc() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.envoy_grpc)
  return _internal_envoy_grpc();
}
inline ::GrpcService_EnvoyGrpc* GrpcService::unsafe_arena_release_envoy_grpc() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.envoy_grpc)
  if (target_specifier_case() == kEnvoyGrpc) {
    clear_has_target_specifier();
    auto* temp = _impl_.target_specifier_.envoy_grpc_;
    _impl_.target_specifier_.envoy_grpc_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService::unsafe_arena_set_allocated_envoy_grpc(::GrpcService_EnvoyGrpc* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_target_specifier();
  if (value) {
    set_has_envoy_grpc();
    _impl_.target_specifier_.envoy_grpc_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.envoy_grpc)
}
inline ::GrpcService_EnvoyGrpc* GrpcService::_internal_mutable_envoy_grpc() {
  if (target_specifier_case() != kEnvoyGrpc) {
    clear_target_specifier();
    set_has_envoy_grpc();
    _impl_.target_specifier_.envoy_grpc_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_EnvoyGrpc>(GetArena());
  }
  return _impl_.target_specifier_.envoy_grpc_;
}
inline ::GrpcService_EnvoyGrpc* GrpcService::mutable_envoy_grpc() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_EnvoyGrpc* _msg = _internal_mutable_envoy_grpc();
  // @@protoc_insertion_point(field_mutable:GrpcService.envoy_grpc)
  return _msg;
}

// .GrpcService.GoogleGrpc google_grpc = 2;
inline bool GrpcService::has_google_grpc() const {
  return target_specifier_case() == kGoogleGrpc;
}
inline bool GrpcService::_internal_has_google_grpc() const {
  return target_specifier_case() == kGoogleGrpc;
}
inline void GrpcService::set_has_google_grpc() {
  _impl_._oneof_case_[0] = kGoogleGrpc;
}
inline void GrpcService::clear_google_grpc() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (target_specifier_case() == kGoogleGrpc) {
    if (GetArena() == nullptr) {
      delete _impl_.target_specifier_.google_grpc_;
    }
    clear_has_target_specifier();
  }
}
inline ::GrpcService_GoogleGrpc* GrpcService::release_google_grpc() {
  // @@protoc_insertion_point(field_release:GrpcService.google_grpc)
  if (target_specifier_case() == kGoogleGrpc) {
    clear_has_target_specifier();
    auto* temp = _impl_.target_specifier_.google_grpc_;
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.target_specifier_.google_grpc_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::GrpcService_GoogleGrpc& GrpcService::_internal_google_grpc() const {
  return target_specifier_case() == kGoogleGrpc ? *_impl_.target_specifier_.google_grpc_ : reinterpret_cast<::GrpcService_GoogleGrpc&>(::_GrpcService_GoogleGrpc_default_instance_);
}
inline const ::GrpcService_GoogleGrpc& GrpcService::google_grpc() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.google_grpc)
  return _internal_google_grpc();
}
inline ::GrpcService_GoogleGrpc* GrpcService::unsafe_arena_release_google_grpc() {
  // @@protoc_insertion_point(field_unsafe_arena_release:GrpcService.google_grpc)
  if (target_specifier_case() == kGoogleGrpc) {
    clear_has_target_specifier();
    auto* temp = _impl_.target_specifier_.google_grpc_;
    _impl_.target_specifier_.google_grpc_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void GrpcService::unsafe_arena_set_allocated_google_grpc(::GrpcService_GoogleGrpc* value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_target_specifier();
  if (value) {
    set_has_google_grpc();
    _impl_.target_specifier_.google_grpc_ = value;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:GrpcService.google_grpc)
}
inline ::GrpcService_GoogleGrpc* GrpcService::_internal_mutable_google_grpc() {
  if (target_specifier_case() != kGoogleGrpc) {
    clear_target_specifier();
    set_has_google_grpc();
    _impl_.target_specifier_.google_grpc_ =
        ::google::protobuf::MessageLite::DefaultConstruct<::GrpcService_GoogleGrpc>(GetArena());
  }
  return _impl_.target_specifier_.google_grpc_;
}
inline ::GrpcService_GoogleGrpc* GrpcService::mutable_google_grpc() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::GrpcService_GoogleGrpc* _msg = _internal_mutable_google_grpc();
  // @@protoc_insertion_point(field_mutable:GrpcService.google_grpc)
  return _msg;
}

// repeated .GrpcService.HeaderValue initial_metadata = 5;
inline int GrpcService::_internal_initial_metadata_size() const {
  return _internal_initial_metadata().size();
}
inline int GrpcService::initial_metadata_size() const {
  return _internal_initial_metadata_size();
}
inline void GrpcService::clear_initial_metadata() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  _impl_.initial_metadata_.Clear();
}
inline ::GrpcService_HeaderValue* GrpcService::mutable_initial_metadata(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:GrpcService.initial_metadata)
  return _internal_mutable_initial_metadata()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::GrpcService_HeaderValue>* GrpcService::mutable_initial_metadata()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable_list:GrpcService.initial_metadata)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  return _internal_mutable_initial_metadata();
}
inline const ::GrpcService_HeaderValue& GrpcService::initial_metadata(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:GrpcService.initial_metadata)
  return _internal_initial_metadata().Get(index);
}
inline ::GrpcService_HeaderValue* GrpcService::add_initial_metadata() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::GrpcService_HeaderValue* _add = _internal_mutable_initial_metadata()->Add();
  // @@protoc_insertion_point(field_add:GrpcService.initial_metadata)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::GrpcService_HeaderValue>& GrpcService::initial_metadata() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:GrpcService.initial_metadata)
  return _internal_initial_metadata();
}
inline const ::google::protobuf::RepeatedPtrField<::GrpcService_HeaderValue>&
GrpcService::_internal_initial_metadata() const {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return _impl_.initial_metadata_;
}
inline ::google::protobuf::RepeatedPtrField<::GrpcService_HeaderValue>*
GrpcService::_internal_mutable_initial_metadata() {
  PROTOBUF_TSAN_READ(&_impl_._tsan_detect_race);
  return &_impl_.initial_metadata_;
}

inline bool GrpcService::has_target_specifier() const {
  return target_specifier_case() != TARGET_SPECIFIER_NOT_SET;
}
inline void GrpcService::clear_has_target_specifier() {
  _impl_._oneof_case_[0] = TARGET_SPECIFIER_NOT_SET;
}
inline GrpcService::TargetSpecifierCase GrpcService::target_specifier_case() const {
  return GrpcService::TargetSpecifierCase(_impl_._oneof_case_[0]);
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"

#endif  // GOOGLE_PROTOBUF_INCLUDED_proxy_5fwasm_5fintrinsics_5flite_2eproto_2epb_2eh