// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: dapr/proto/common/v1/common.proto

#ifndef PROTOBUF_INCLUDED_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto
#define PROTOBUF_INCLUDED_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/any.pb.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto 

namespace protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[9];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto
namespace dapr {
namespace proto {
namespace common {
namespace v1 {
class ConfigurationItem;
class ConfigurationItemDefaultTypeInternal;
extern ConfigurationItemDefaultTypeInternal _ConfigurationItem_default_instance_;
class ConfigurationItem_MetadataEntry_DoNotUse;
class ConfigurationItem_MetadataEntry_DoNotUseDefaultTypeInternal;
extern ConfigurationItem_MetadataEntry_DoNotUseDefaultTypeInternal _ConfigurationItem_MetadataEntry_DoNotUse_default_instance_;
class Etag;
class EtagDefaultTypeInternal;
extern EtagDefaultTypeInternal _Etag_default_instance_;
class HTTPExtension;
class HTTPExtensionDefaultTypeInternal;
extern HTTPExtensionDefaultTypeInternal _HTTPExtension_default_instance_;
class InvokeRequest;
class InvokeRequestDefaultTypeInternal;
extern InvokeRequestDefaultTypeInternal _InvokeRequest_default_instance_;
class InvokeResponse;
class InvokeResponseDefaultTypeInternal;
extern InvokeResponseDefaultTypeInternal _InvokeResponse_default_instance_;
class StateItem;
class StateItemDefaultTypeInternal;
extern StateItemDefaultTypeInternal _StateItem_default_instance_;
class StateItem_MetadataEntry_DoNotUse;
class StateItem_MetadataEntry_DoNotUseDefaultTypeInternal;
extern StateItem_MetadataEntry_DoNotUseDefaultTypeInternal _StateItem_MetadataEntry_DoNotUse_default_instance_;
class StateOptions;
class StateOptionsDefaultTypeInternal;
extern StateOptionsDefaultTypeInternal _StateOptions_default_instance_;
}  // namespace v1
}  // namespace common
}  // namespace proto
}  // namespace dapr
namespace google {
namespace protobuf {
template<> ::dapr::proto::common::v1::ConfigurationItem* Arena::CreateMaybeMessage<::dapr::proto::common::v1::ConfigurationItem>(Arena*);
template<> ::dapr::proto::common::v1::ConfigurationItem_MetadataEntry_DoNotUse* Arena::CreateMaybeMessage<::dapr::proto::common::v1::ConfigurationItem_MetadataEntry_DoNotUse>(Arena*);
template<> ::dapr::proto::common::v1::Etag* Arena::CreateMaybeMessage<::dapr::proto::common::v1::Etag>(Arena*);
template<> ::dapr::proto::common::v1::HTTPExtension* Arena::CreateMaybeMessage<::dapr::proto::common::v1::HTTPExtension>(Arena*);
template<> ::dapr::proto::common::v1::InvokeRequest* Arena::CreateMaybeMessage<::dapr::proto::common::v1::InvokeRequest>(Arena*);
template<> ::dapr::proto::common::v1::InvokeResponse* Arena::CreateMaybeMessage<::dapr::proto::common::v1::InvokeResponse>(Arena*);
template<> ::dapr::proto::common::v1::StateItem* Arena::CreateMaybeMessage<::dapr::proto::common::v1::StateItem>(Arena*);
template<> ::dapr::proto::common::v1::StateItem_MetadataEntry_DoNotUse* Arena::CreateMaybeMessage<::dapr::proto::common::v1::StateItem_MetadataEntry_DoNotUse>(Arena*);
template<> ::dapr::proto::common::v1::StateOptions* Arena::CreateMaybeMessage<::dapr::proto::common::v1::StateOptions>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace dapr {
namespace proto {
namespace common {
namespace v1 {

enum HTTPExtension_Verb {
  HTTPExtension_Verb_NONE = 0,
  HTTPExtension_Verb_GET = 1,
  HTTPExtension_Verb_HEAD = 2,
  HTTPExtension_Verb_POST = 3,
  HTTPExtension_Verb_PUT = 4,
  HTTPExtension_Verb_DELETE = 5,
  HTTPExtension_Verb_CONNECT = 6,
  HTTPExtension_Verb_OPTIONS = 7,
  HTTPExtension_Verb_TRACE = 8,
  HTTPExtension_Verb_PATCH = 9,
  HTTPExtension_Verb_HTTPExtension_Verb_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  HTTPExtension_Verb_HTTPExtension_Verb_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool HTTPExtension_Verb_IsValid(int value);
const HTTPExtension_Verb HTTPExtension_Verb_Verb_MIN = HTTPExtension_Verb_NONE;
const HTTPExtension_Verb HTTPExtension_Verb_Verb_MAX = HTTPExtension_Verb_PATCH;
const int HTTPExtension_Verb_Verb_ARRAYSIZE = HTTPExtension_Verb_Verb_MAX + 1;

const ::google::protobuf::EnumDescriptor* HTTPExtension_Verb_descriptor();
inline const ::std::string& HTTPExtension_Verb_Name(HTTPExtension_Verb value) {
  return ::google::protobuf::internal::NameOfEnum(
    HTTPExtension_Verb_descriptor(), value);
}
inline bool HTTPExtension_Verb_Parse(
    const ::std::string& name, HTTPExtension_Verb* value) {
  return ::google::protobuf::internal::ParseNamedEnum<HTTPExtension_Verb>(
    HTTPExtension_Verb_descriptor(), name, value);
}
enum StateOptions_StateConcurrency {
  StateOptions_StateConcurrency_CONCURRENCY_UNSPECIFIED = 0,
  StateOptions_StateConcurrency_CONCURRENCY_FIRST_WRITE = 1,
  StateOptions_StateConcurrency_CONCURRENCY_LAST_WRITE = 2,
  StateOptions_StateConcurrency_StateOptions_StateConcurrency_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  StateOptions_StateConcurrency_StateOptions_StateConcurrency_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool StateOptions_StateConcurrency_IsValid(int value);
const StateOptions_StateConcurrency StateOptions_StateConcurrency_StateConcurrency_MIN = StateOptions_StateConcurrency_CONCURRENCY_UNSPECIFIED;
const StateOptions_StateConcurrency StateOptions_StateConcurrency_StateConcurrency_MAX = StateOptions_StateConcurrency_CONCURRENCY_LAST_WRITE;
const int StateOptions_StateConcurrency_StateConcurrency_ARRAYSIZE = StateOptions_StateConcurrency_StateConcurrency_MAX + 1;

const ::google::protobuf::EnumDescriptor* StateOptions_StateConcurrency_descriptor();
inline const ::std::string& StateOptions_StateConcurrency_Name(StateOptions_StateConcurrency value) {
  return ::google::protobuf::internal::NameOfEnum(
    StateOptions_StateConcurrency_descriptor(), value);
}
inline bool StateOptions_StateConcurrency_Parse(
    const ::std::string& name, StateOptions_StateConcurrency* value) {
  return ::google::protobuf::internal::ParseNamedEnum<StateOptions_StateConcurrency>(
    StateOptions_StateConcurrency_descriptor(), name, value);
}
enum StateOptions_StateConsistency {
  StateOptions_StateConsistency_CONSISTENCY_UNSPECIFIED = 0,
  StateOptions_StateConsistency_CONSISTENCY_EVENTUAL = 1,
  StateOptions_StateConsistency_CONSISTENCY_STRONG = 2,
  StateOptions_StateConsistency_StateOptions_StateConsistency_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  StateOptions_StateConsistency_StateOptions_StateConsistency_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool StateOptions_StateConsistency_IsValid(int value);
const StateOptions_StateConsistency StateOptions_StateConsistency_StateConsistency_MIN = StateOptions_StateConsistency_CONSISTENCY_UNSPECIFIED;
const StateOptions_StateConsistency StateOptions_StateConsistency_StateConsistency_MAX = StateOptions_StateConsistency_CONSISTENCY_STRONG;
const int StateOptions_StateConsistency_StateConsistency_ARRAYSIZE = StateOptions_StateConsistency_StateConsistency_MAX + 1;

const ::google::protobuf::EnumDescriptor* StateOptions_StateConsistency_descriptor();
inline const ::std::string& StateOptions_StateConsistency_Name(StateOptions_StateConsistency value) {
  return ::google::protobuf::internal::NameOfEnum(
    StateOptions_StateConsistency_descriptor(), value);
}
inline bool StateOptions_StateConsistency_Parse(
    const ::std::string& name, StateOptions_StateConsistency* value) {
  return ::google::protobuf::internal::ParseNamedEnum<StateOptions_StateConsistency>(
    StateOptions_StateConsistency_descriptor(), name, value);
}
// ===================================================================

class HTTPExtension : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dapr.proto.common.v1.HTTPExtension) */ {
 public:
  HTTPExtension();
  virtual ~HTTPExtension();

  HTTPExtension(const HTTPExtension& from);

  inline HTTPExtension& operator=(const HTTPExtension& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  HTTPExtension(HTTPExtension&& from) noexcept
    : HTTPExtension() {
    *this = ::std::move(from);
  }

  inline HTTPExtension& operator=(HTTPExtension&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const HTTPExtension& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const HTTPExtension* internal_default_instance() {
    return reinterpret_cast<const HTTPExtension*>(
               &_HTTPExtension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(HTTPExtension* other);
  friend void swap(HTTPExtension& a, HTTPExtension& b) {
    a.Swap(&b);
  }

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

  inline HTTPExtension* New() const final {
    return CreateMaybeMessage<HTTPExtension>(NULL);
  }

  HTTPExtension* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<HTTPExtension>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const HTTPExtension& from);
  void MergeFrom(const HTTPExtension& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HTTPExtension* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef HTTPExtension_Verb Verb;
  static const Verb NONE =
    HTTPExtension_Verb_NONE;
  static const Verb GET =
    HTTPExtension_Verb_GET;
  static const Verb HEAD =
    HTTPExtension_Verb_HEAD;
  static const Verb POST =
    HTTPExtension_Verb_POST;
  static const Verb PUT =
    HTTPExtension_Verb_PUT;
  static const Verb DELETE =
    HTTPExtension_Verb_DELETE;
  static const Verb CONNECT =
    HTTPExtension_Verb_CONNECT;
  static const Verb OPTIONS =
    HTTPExtension_Verb_OPTIONS;
  static const Verb TRACE =
    HTTPExtension_Verb_TRACE;
  static const Verb PATCH =
    HTTPExtension_Verb_PATCH;
  static inline bool Verb_IsValid(int value) {
    return HTTPExtension_Verb_IsValid(value);
  }
  static const Verb Verb_MIN =
    HTTPExtension_Verb_Verb_MIN;
  static const Verb Verb_MAX =
    HTTPExtension_Verb_Verb_MAX;
  static const int Verb_ARRAYSIZE =
    HTTPExtension_Verb_Verb_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Verb_descriptor() {
    return HTTPExtension_Verb_descriptor();
  }
  static inline const ::std::string& Verb_Name(Verb value) {
    return HTTPExtension_Verb_Name(value);
  }
  static inline bool Verb_Parse(const ::std::string& name,
      Verb* value) {
    return HTTPExtension_Verb_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // string querystring = 2;
  void clear_querystring();
  static const int kQuerystringFieldNumber = 2;
  const ::std::string& querystring() const;
  void set_querystring(const ::std::string& value);
  #if LANG_CXX11
  void set_querystring(::std::string&& value);
  #endif
  void set_querystring(const char* value);
  void set_querystring(const char* value, size_t size);
  ::std::string* mutable_querystring();
  ::std::string* release_querystring();
  void set_allocated_querystring(::std::string* querystring);

  // .dapr.proto.common.v1.HTTPExtension.Verb verb = 1;
  void clear_verb();
  static const int kVerbFieldNumber = 1;
  ::dapr::proto::common::v1::HTTPExtension_Verb verb() const;
  void set_verb(::dapr::proto::common::v1::HTTPExtension_Verb value);

  // @@protoc_insertion_point(class_scope:dapr.proto.common.v1.HTTPExtension)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr querystring_;
  int verb_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class InvokeRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dapr.proto.common.v1.InvokeRequest) */ {
 public:
  InvokeRequest();
  virtual ~InvokeRequest();

  InvokeRequest(const InvokeRequest& from);

  inline InvokeRequest& operator=(const InvokeRequest& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  InvokeRequest(InvokeRequest&& from) noexcept
    : InvokeRequest() {
    *this = ::std::move(from);
  }

  inline InvokeRequest& operator=(InvokeRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const InvokeRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const InvokeRequest* internal_default_instance() {
    return reinterpret_cast<const InvokeRequest*>(
               &_InvokeRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(InvokeRequest* other);
  friend void swap(InvokeRequest& a, InvokeRequest& b) {
    a.Swap(&b);
  }

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

  inline InvokeRequest* New() const final {
    return CreateMaybeMessage<InvokeRequest>(NULL);
  }

  InvokeRequest* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<InvokeRequest>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const InvokeRequest& from);
  void MergeFrom(const InvokeRequest& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InvokeRequest* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string method = 1;
  void clear_method();
  static const int kMethodFieldNumber = 1;
  const ::std::string& method() const;
  void set_method(const ::std::string& value);
  #if LANG_CXX11
  void set_method(::std::string&& value);
  #endif
  void set_method(const char* value);
  void set_method(const char* value, size_t size);
  ::std::string* mutable_method();
  ::std::string* release_method();
  void set_allocated_method(::std::string* method);

  // string content_type = 3;
  void clear_content_type();
  static const int kContentTypeFieldNumber = 3;
  const ::std::string& content_type() const;
  void set_content_type(const ::std::string& value);
  #if LANG_CXX11
  void set_content_type(::std::string&& value);
  #endif
  void set_content_type(const char* value);
  void set_content_type(const char* value, size_t size);
  ::std::string* mutable_content_type();
  ::std::string* release_content_type();
  void set_allocated_content_type(::std::string* content_type);

  // .google.protobuf.Any data = 2;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 2;
  private:
  const ::google::protobuf::Any& _internal_data() const;
  public:
  const ::google::protobuf::Any& data() const;
  ::google::protobuf::Any* release_data();
  ::google::protobuf::Any* mutable_data();
  void set_allocated_data(::google::protobuf::Any* data);

  // .dapr.proto.common.v1.HTTPExtension http_extension = 4;
  bool has_http_extension() const;
  void clear_http_extension();
  static const int kHttpExtensionFieldNumber = 4;
  private:
  const ::dapr::proto::common::v1::HTTPExtension& _internal_http_extension() const;
  public:
  const ::dapr::proto::common::v1::HTTPExtension& http_extension() const;
  ::dapr::proto::common::v1::HTTPExtension* release_http_extension();
  ::dapr::proto::common::v1::HTTPExtension* mutable_http_extension();
  void set_allocated_http_extension(::dapr::proto::common::v1::HTTPExtension* http_extension);

  // @@protoc_insertion_point(class_scope:dapr.proto.common.v1.InvokeRequest)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr method_;
  ::google::protobuf::internal::ArenaStringPtr content_type_;
  ::google::protobuf::Any* data_;
  ::dapr::proto::common::v1::HTTPExtension* http_extension_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class InvokeResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dapr.proto.common.v1.InvokeResponse) */ {
 public:
  InvokeResponse();
  virtual ~InvokeResponse();

  InvokeResponse(const InvokeResponse& from);

  inline InvokeResponse& operator=(const InvokeResponse& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  InvokeResponse(InvokeResponse&& from) noexcept
    : InvokeResponse() {
    *this = ::std::move(from);
  }

  inline InvokeResponse& operator=(InvokeResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const InvokeResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const InvokeResponse* internal_default_instance() {
    return reinterpret_cast<const InvokeResponse*>(
               &_InvokeResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(InvokeResponse* other);
  friend void swap(InvokeResponse& a, InvokeResponse& b) {
    a.Swap(&b);
  }

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

  inline InvokeResponse* New() const final {
    return CreateMaybeMessage<InvokeResponse>(NULL);
  }

  InvokeResponse* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<InvokeResponse>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const InvokeResponse& from);
  void MergeFrom(const InvokeResponse& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InvokeResponse* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string content_type = 2;
  void clear_content_type();
  static const int kContentTypeFieldNumber = 2;
  const ::std::string& content_type() const;
  void set_content_type(const ::std::string& value);
  #if LANG_CXX11
  void set_content_type(::std::string&& value);
  #endif
  void set_content_type(const char* value);
  void set_content_type(const char* value, size_t size);
  ::std::string* mutable_content_type();
  ::std::string* release_content_type();
  void set_allocated_content_type(::std::string* content_type);

  // .google.protobuf.Any data = 1;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  private:
  const ::google::protobuf::Any& _internal_data() const;
  public:
  const ::google::protobuf::Any& data() const;
  ::google::protobuf::Any* release_data();
  ::google::protobuf::Any* mutable_data();
  void set_allocated_data(::google::protobuf::Any* data);

  // @@protoc_insertion_point(class_scope:dapr.proto.common.v1.InvokeResponse)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr content_type_;
  ::google::protobuf::Any* data_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class StateItem_MetadataEntry_DoNotUse : public ::google::protobuf::internal::MapEntry<StateItem_MetadataEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > {
public:
  typedef ::google::protobuf::internal::MapEntry<StateItem_MetadataEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > SuperType;
  StateItem_MetadataEntry_DoNotUse();
  StateItem_MetadataEntry_DoNotUse(::google::protobuf::Arena* arena);
  void MergeFrom(const StateItem_MetadataEntry_DoNotUse& other);
  static const StateItem_MetadataEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const StateItem_MetadataEntry_DoNotUse*>(&_StateItem_MetadataEntry_DoNotUse_default_instance_); }
  void MergeFrom(const ::google::protobuf::Message& other) final;
  ::google::protobuf::Metadata GetMetadata() const;
};

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

class StateItem : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dapr.proto.common.v1.StateItem) */ {
 public:
  StateItem();
  virtual ~StateItem();

  StateItem(const StateItem& from);

  inline StateItem& operator=(const StateItem& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StateItem(StateItem&& from) noexcept
    : StateItem() {
    *this = ::std::move(from);
  }

  inline StateItem& operator=(StateItem&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const StateItem& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StateItem* internal_default_instance() {
    return reinterpret_cast<const StateItem*>(
               &_StateItem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(StateItem* other);
  friend void swap(StateItem& a, StateItem& b) {
    a.Swap(&b);
  }

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

  inline StateItem* New() const final {
    return CreateMaybeMessage<StateItem>(NULL);
  }

  StateItem* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StateItem>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StateItem& from);
  void MergeFrom(const StateItem& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StateItem* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  // map<string, string> metadata = 4;
  int metadata_size() const;
  void clear_metadata();
  static const int kMetadataFieldNumber = 4;
  const ::google::protobuf::Map< ::std::string, ::std::string >&
      metadata() const;
  ::google::protobuf::Map< ::std::string, ::std::string >*
      mutable_metadata();

  // string key = 1;
  void clear_key();
  static const int kKeyFieldNumber = 1;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  #if LANG_CXX11
  void set_key(::std::string&& value);
  #endif
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // bytes value = 2;
  void clear_value();
  static const int kValueFieldNumber = 2;
  const ::std::string& value() const;
  void set_value(const ::std::string& value);
  #if LANG_CXX11
  void set_value(::std::string&& value);
  #endif
  void set_value(const char* value);
  void set_value(const void* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // .dapr.proto.common.v1.Etag etag = 3;
  bool has_etag() const;
  void clear_etag();
  static const int kEtagFieldNumber = 3;
  private:
  const ::dapr::proto::common::v1::Etag& _internal_etag() const;
  public:
  const ::dapr::proto::common::v1::Etag& etag() const;
  ::dapr::proto::common::v1::Etag* release_etag();
  ::dapr::proto::common::v1::Etag* mutable_etag();
  void set_allocated_etag(::dapr::proto::common::v1::Etag* etag);

  // .dapr.proto.common.v1.StateOptions options = 5;
  bool has_options() const;
  void clear_options();
  static const int kOptionsFieldNumber = 5;
  private:
  const ::dapr::proto::common::v1::StateOptions& _internal_options() const;
  public:
  const ::dapr::proto::common::v1::StateOptions& options() const;
  ::dapr::proto::common::v1::StateOptions* release_options();
  ::dapr::proto::common::v1::StateOptions* mutable_options();
  void set_allocated_options(::dapr::proto::common::v1::StateOptions* options);

  // @@protoc_insertion_point(class_scope:dapr.proto.common.v1.StateItem)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::MapField<
      StateItem_MetadataEntry_DoNotUse,
      ::std::string, ::std::string,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      0 > metadata_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  ::dapr::proto::common::v1::Etag* etag_;
  ::dapr::proto::common::v1::StateOptions* options_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Etag : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dapr.proto.common.v1.Etag) */ {
 public:
  Etag();
  virtual ~Etag();

  Etag(const Etag& from);

  inline Etag& operator=(const Etag& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Etag(Etag&& from) noexcept
    : Etag() {
    *this = ::std::move(from);
  }

  inline Etag& operator=(Etag&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Etag& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Etag* internal_default_instance() {
    return reinterpret_cast<const Etag*>(
               &_Etag_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(Etag* other);
  friend void swap(Etag& a, Etag& b) {
    a.Swap(&b);
  }

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

  inline Etag* New() const final {
    return CreateMaybeMessage<Etag>(NULL);
  }

  Etag* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Etag>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Etag& from);
  void MergeFrom(const Etag& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Etag* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string value = 1;
  void clear_value();
  static const int kValueFieldNumber = 1;
  const ::std::string& value() const;
  void set_value(const ::std::string& value);
  #if LANG_CXX11
  void set_value(::std::string&& value);
  #endif
  void set_value(const char* value);
  void set_value(const char* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // @@protoc_insertion_point(class_scope:dapr.proto.common.v1.Etag)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class StateOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dapr.proto.common.v1.StateOptions) */ {
 public:
  StateOptions();
  virtual ~StateOptions();

  StateOptions(const StateOptions& from);

  inline StateOptions& operator=(const StateOptions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StateOptions(StateOptions&& from) noexcept
    : StateOptions() {
    *this = ::std::move(from);
  }

  inline StateOptions& operator=(StateOptions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const StateOptions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StateOptions* internal_default_instance() {
    return reinterpret_cast<const StateOptions*>(
               &_StateOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(StateOptions* other);
  friend void swap(StateOptions& a, StateOptions& b) {
    a.Swap(&b);
  }

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

  inline StateOptions* New() const final {
    return CreateMaybeMessage<StateOptions>(NULL);
  }

  StateOptions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StateOptions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const StateOptions& from);
  void MergeFrom(const StateOptions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StateOptions* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef StateOptions_StateConcurrency StateConcurrency;
  static const StateConcurrency CONCURRENCY_UNSPECIFIED =
    StateOptions_StateConcurrency_CONCURRENCY_UNSPECIFIED;
  static const StateConcurrency CONCURRENCY_FIRST_WRITE =
    StateOptions_StateConcurrency_CONCURRENCY_FIRST_WRITE;
  static const StateConcurrency CONCURRENCY_LAST_WRITE =
    StateOptions_StateConcurrency_CONCURRENCY_LAST_WRITE;
  static inline bool StateConcurrency_IsValid(int value) {
    return StateOptions_StateConcurrency_IsValid(value);
  }
  static const StateConcurrency StateConcurrency_MIN =
    StateOptions_StateConcurrency_StateConcurrency_MIN;
  static const StateConcurrency StateConcurrency_MAX =
    StateOptions_StateConcurrency_StateConcurrency_MAX;
  static const int StateConcurrency_ARRAYSIZE =
    StateOptions_StateConcurrency_StateConcurrency_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  StateConcurrency_descriptor() {
    return StateOptions_StateConcurrency_descriptor();
  }
  static inline const ::std::string& StateConcurrency_Name(StateConcurrency value) {
    return StateOptions_StateConcurrency_Name(value);
  }
  static inline bool StateConcurrency_Parse(const ::std::string& name,
      StateConcurrency* value) {
    return StateOptions_StateConcurrency_Parse(name, value);
  }

  typedef StateOptions_StateConsistency StateConsistency;
  static const StateConsistency CONSISTENCY_UNSPECIFIED =
    StateOptions_StateConsistency_CONSISTENCY_UNSPECIFIED;
  static const StateConsistency CONSISTENCY_EVENTUAL =
    StateOptions_StateConsistency_CONSISTENCY_EVENTUAL;
  static const StateConsistency CONSISTENCY_STRONG =
    StateOptions_StateConsistency_CONSISTENCY_STRONG;
  static inline bool StateConsistency_IsValid(int value) {
    return StateOptions_StateConsistency_IsValid(value);
  }
  static const StateConsistency StateConsistency_MIN =
    StateOptions_StateConsistency_StateConsistency_MIN;
  static const StateConsistency StateConsistency_MAX =
    StateOptions_StateConsistency_StateConsistency_MAX;
  static const int StateConsistency_ARRAYSIZE =
    StateOptions_StateConsistency_StateConsistency_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  StateConsistency_descriptor() {
    return StateOptions_StateConsistency_descriptor();
  }
  static inline const ::std::string& StateConsistency_Name(StateConsistency value) {
    return StateOptions_StateConsistency_Name(value);
  }
  static inline bool StateConsistency_Parse(const ::std::string& name,
      StateConsistency* value) {
    return StateOptions_StateConsistency_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // .dapr.proto.common.v1.StateOptions.StateConcurrency concurrency = 1;
  void clear_concurrency();
  static const int kConcurrencyFieldNumber = 1;
  ::dapr::proto::common::v1::StateOptions_StateConcurrency concurrency() const;
  void set_concurrency(::dapr::proto::common::v1::StateOptions_StateConcurrency value);

  // .dapr.proto.common.v1.StateOptions.StateConsistency consistency = 2;
  void clear_consistency();
  static const int kConsistencyFieldNumber = 2;
  ::dapr::proto::common::v1::StateOptions_StateConsistency consistency() const;
  void set_consistency(::dapr::proto::common::v1::StateOptions_StateConsistency value);

  // @@protoc_insertion_point(class_scope:dapr.proto.common.v1.StateOptions)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  int concurrency_;
  int consistency_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ConfigurationItem_MetadataEntry_DoNotUse : public ::google::protobuf::internal::MapEntry<ConfigurationItem_MetadataEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > {
public:
  typedef ::google::protobuf::internal::MapEntry<ConfigurationItem_MetadataEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > SuperType;
  ConfigurationItem_MetadataEntry_DoNotUse();
  ConfigurationItem_MetadataEntry_DoNotUse(::google::protobuf::Arena* arena);
  void MergeFrom(const ConfigurationItem_MetadataEntry_DoNotUse& other);
  static const ConfigurationItem_MetadataEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ConfigurationItem_MetadataEntry_DoNotUse*>(&_ConfigurationItem_MetadataEntry_DoNotUse_default_instance_); }
  void MergeFrom(const ::google::protobuf::Message& other) final;
  ::google::protobuf::Metadata GetMetadata() const;
};

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

class ConfigurationItem : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dapr.proto.common.v1.ConfigurationItem) */ {
 public:
  ConfigurationItem();
  virtual ~ConfigurationItem();

  ConfigurationItem(const ConfigurationItem& from);

  inline ConfigurationItem& operator=(const ConfigurationItem& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ConfigurationItem(ConfigurationItem&& from) noexcept
    : ConfigurationItem() {
    *this = ::std::move(from);
  }

  inline ConfigurationItem& operator=(ConfigurationItem&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ConfigurationItem& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ConfigurationItem* internal_default_instance() {
    return reinterpret_cast<const ConfigurationItem*>(
               &_ConfigurationItem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  void Swap(ConfigurationItem* other);
  friend void swap(ConfigurationItem& a, ConfigurationItem& b) {
    a.Swap(&b);
  }

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

  inline ConfigurationItem* New() const final {
    return CreateMaybeMessage<ConfigurationItem>(NULL);
  }

  ConfigurationItem* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ConfigurationItem>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ConfigurationItem& from);
  void MergeFrom(const ConfigurationItem& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConfigurationItem* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  // map<string, string> metadata = 4;
  int metadata_size() const;
  void clear_metadata();
  static const int kMetadataFieldNumber = 4;
  const ::google::protobuf::Map< ::std::string, ::std::string >&
      metadata() const;
  ::google::protobuf::Map< ::std::string, ::std::string >*
      mutable_metadata();

  // string key = 1;
  void clear_key();
  static const int kKeyFieldNumber = 1;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  #if LANG_CXX11
  void set_key(::std::string&& value);
  #endif
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // string value = 2;
  void clear_value();
  static const int kValueFieldNumber = 2;
  const ::std::string& value() const;
  void set_value(const ::std::string& value);
  #if LANG_CXX11
  void set_value(::std::string&& value);
  #endif
  void set_value(const char* value);
  void set_value(const char* value, size_t size);
  ::std::string* mutable_value();
  ::std::string* release_value();
  void set_allocated_value(::std::string* value);

  // string version = 3;
  void clear_version();
  static const int kVersionFieldNumber = 3;
  const ::std::string& version() const;
  void set_version(const ::std::string& value);
  #if LANG_CXX11
  void set_version(::std::string&& value);
  #endif
  void set_version(const char* value);
  void set_version(const char* value, size_t size);
  ::std::string* mutable_version();
  ::std::string* release_version();
  void set_allocated_version(::std::string* version);

  // @@protoc_insertion_point(class_scope:dapr.proto.common.v1.ConfigurationItem)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::MapField<
      ConfigurationItem_MetadataEntry_DoNotUse,
      ::std::string, ::std::string,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      0 > metadata_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::internal::ArenaStringPtr value_;
  ::google::protobuf::internal::ArenaStringPtr version_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto::TableStruct;
};
// ===================================================================


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

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

// .dapr.proto.common.v1.HTTPExtension.Verb verb = 1;
inline void HTTPExtension::clear_verb() {
  verb_ = 0;
}
inline ::dapr::proto::common::v1::HTTPExtension_Verb HTTPExtension::verb() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.HTTPExtension.verb)
  return static_cast< ::dapr::proto::common::v1::HTTPExtension_Verb >(verb_);
}
inline void HTTPExtension::set_verb(::dapr::proto::common::v1::HTTPExtension_Verb value) {
  
  verb_ = value;
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.HTTPExtension.verb)
}

// string querystring = 2;
inline void HTTPExtension::clear_querystring() {
  querystring_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& HTTPExtension::querystring() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.HTTPExtension.querystring)
  return querystring_.GetNoArena();
}
inline void HTTPExtension::set_querystring(const ::std::string& value) {
  
  querystring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.HTTPExtension.querystring)
}
#if LANG_CXX11
inline void HTTPExtension::set_querystring(::std::string&& value) {
  
  querystring_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.HTTPExtension.querystring)
}
#endif
inline void HTTPExtension::set_querystring(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  querystring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.HTTPExtension.querystring)
}
inline void HTTPExtension::set_querystring(const char* value, size_t size) {
  
  querystring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.HTTPExtension.querystring)
}
inline ::std::string* HTTPExtension::mutable_querystring() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.HTTPExtension.querystring)
  return querystring_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* HTTPExtension::release_querystring() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.HTTPExtension.querystring)
  
  return querystring_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void HTTPExtension::set_allocated_querystring(::std::string* querystring) {
  if (querystring != NULL) {
    
  } else {
    
  }
  querystring_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), querystring);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.HTTPExtension.querystring)
}

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

// InvokeRequest

// string method = 1;
inline void InvokeRequest::clear_method() {
  method_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& InvokeRequest::method() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.InvokeRequest.method)
  return method_.GetNoArena();
}
inline void InvokeRequest::set_method(const ::std::string& value) {
  
  method_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.InvokeRequest.method)
}
#if LANG_CXX11
inline void InvokeRequest::set_method(::std::string&& value) {
  
  method_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.InvokeRequest.method)
}
#endif
inline void InvokeRequest::set_method(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  method_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.InvokeRequest.method)
}
inline void InvokeRequest::set_method(const char* value, size_t size) {
  
  method_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.InvokeRequest.method)
}
inline ::std::string* InvokeRequest::mutable_method() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.InvokeRequest.method)
  return method_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* InvokeRequest::release_method() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.InvokeRequest.method)
  
  return method_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void InvokeRequest::set_allocated_method(::std::string* method) {
  if (method != NULL) {
    
  } else {
    
  }
  method_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), method);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.InvokeRequest.method)
}

// .google.protobuf.Any data = 2;
inline bool InvokeRequest::has_data() const {
  return this != internal_default_instance() && data_ != NULL;
}
inline const ::google::protobuf::Any& InvokeRequest::_internal_data() const {
  return *data_;
}
inline const ::google::protobuf::Any& InvokeRequest::data() const {
  const ::google::protobuf::Any* p = data_;
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.InvokeRequest.data)
  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::Any*>(
      &::google::protobuf::_Any_default_instance_);
}
inline ::google::protobuf::Any* InvokeRequest::release_data() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.InvokeRequest.data)
  
  ::google::protobuf::Any* temp = data_;
  data_ = NULL;
  return temp;
}
inline ::google::protobuf::Any* InvokeRequest::mutable_data() {
  
  if (data_ == NULL) {
    auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArenaNoVirtual());
    data_ = p;
  }
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.InvokeRequest.data)
  return data_;
}
inline void InvokeRequest::set_allocated_data(::google::protobuf::Any* data) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(data_);
  }
  if (data) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      data = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    
  } else {
    
  }
  data_ = data;
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.InvokeRequest.data)
}

// string content_type = 3;
inline void InvokeRequest::clear_content_type() {
  content_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& InvokeRequest::content_type() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.InvokeRequest.content_type)
  return content_type_.GetNoArena();
}
inline void InvokeRequest::set_content_type(const ::std::string& value) {
  
  content_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.InvokeRequest.content_type)
}
#if LANG_CXX11
inline void InvokeRequest::set_content_type(::std::string&& value) {
  
  content_type_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.InvokeRequest.content_type)
}
#endif
inline void InvokeRequest::set_content_type(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  content_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.InvokeRequest.content_type)
}
inline void InvokeRequest::set_content_type(const char* value, size_t size) {
  
  content_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.InvokeRequest.content_type)
}
inline ::std::string* InvokeRequest::mutable_content_type() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.InvokeRequest.content_type)
  return content_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* InvokeRequest::release_content_type() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.InvokeRequest.content_type)
  
  return content_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void InvokeRequest::set_allocated_content_type(::std::string* content_type) {
  if (content_type != NULL) {
    
  } else {
    
  }
  content_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), content_type);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.InvokeRequest.content_type)
}

// .dapr.proto.common.v1.HTTPExtension http_extension = 4;
inline bool InvokeRequest::has_http_extension() const {
  return this != internal_default_instance() && http_extension_ != NULL;
}
inline void InvokeRequest::clear_http_extension() {
  if (GetArenaNoVirtual() == NULL && http_extension_ != NULL) {
    delete http_extension_;
  }
  http_extension_ = NULL;
}
inline const ::dapr::proto::common::v1::HTTPExtension& InvokeRequest::_internal_http_extension() const {
  return *http_extension_;
}
inline const ::dapr::proto::common::v1::HTTPExtension& InvokeRequest::http_extension() const {
  const ::dapr::proto::common::v1::HTTPExtension* p = http_extension_;
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.InvokeRequest.http_extension)
  return p != NULL ? *p : *reinterpret_cast<const ::dapr::proto::common::v1::HTTPExtension*>(
      &::dapr::proto::common::v1::_HTTPExtension_default_instance_);
}
inline ::dapr::proto::common::v1::HTTPExtension* InvokeRequest::release_http_extension() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.InvokeRequest.http_extension)
  
  ::dapr::proto::common::v1::HTTPExtension* temp = http_extension_;
  http_extension_ = NULL;
  return temp;
}
inline ::dapr::proto::common::v1::HTTPExtension* InvokeRequest::mutable_http_extension() {
  
  if (http_extension_ == NULL) {
    auto* p = CreateMaybeMessage<::dapr::proto::common::v1::HTTPExtension>(GetArenaNoVirtual());
    http_extension_ = p;
  }
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.InvokeRequest.http_extension)
  return http_extension_;
}
inline void InvokeRequest::set_allocated_http_extension(::dapr::proto::common::v1::HTTPExtension* http_extension) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete http_extension_;
  }
  if (http_extension) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      http_extension = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, http_extension, submessage_arena);
    }
    
  } else {
    
  }
  http_extension_ = http_extension;
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.InvokeRequest.http_extension)
}

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

// InvokeResponse

// .google.protobuf.Any data = 1;
inline bool InvokeResponse::has_data() const {
  return this != internal_default_instance() && data_ != NULL;
}
inline const ::google::protobuf::Any& InvokeResponse::_internal_data() const {
  return *data_;
}
inline const ::google::protobuf::Any& InvokeResponse::data() const {
  const ::google::protobuf::Any* p = data_;
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.InvokeResponse.data)
  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::Any*>(
      &::google::protobuf::_Any_default_instance_);
}
inline ::google::protobuf::Any* InvokeResponse::release_data() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.InvokeResponse.data)
  
  ::google::protobuf::Any* temp = data_;
  data_ = NULL;
  return temp;
}
inline ::google::protobuf::Any* InvokeResponse::mutable_data() {
  
  if (data_ == NULL) {
    auto* p = CreateMaybeMessage<::google::protobuf::Any>(GetArenaNoVirtual());
    data_ = p;
  }
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.InvokeResponse.data)
  return data_;
}
inline void InvokeResponse::set_allocated_data(::google::protobuf::Any* data) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(data_);
  }
  if (data) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      data = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    
  } else {
    
  }
  data_ = data;
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.InvokeResponse.data)
}

// string content_type = 2;
inline void InvokeResponse::clear_content_type() {
  content_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& InvokeResponse::content_type() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.InvokeResponse.content_type)
  return content_type_.GetNoArena();
}
inline void InvokeResponse::set_content_type(const ::std::string& value) {
  
  content_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.InvokeResponse.content_type)
}
#if LANG_CXX11
inline void InvokeResponse::set_content_type(::std::string&& value) {
  
  content_type_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.InvokeResponse.content_type)
}
#endif
inline void InvokeResponse::set_content_type(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  content_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.InvokeResponse.content_type)
}
inline void InvokeResponse::set_content_type(const char* value, size_t size) {
  
  content_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.InvokeResponse.content_type)
}
inline ::std::string* InvokeResponse::mutable_content_type() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.InvokeResponse.content_type)
  return content_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* InvokeResponse::release_content_type() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.InvokeResponse.content_type)
  
  return content_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void InvokeResponse::set_allocated_content_type(::std::string* content_type) {
  if (content_type != NULL) {
    
  } else {
    
  }
  content_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), content_type);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.InvokeResponse.content_type)
}

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

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

// StateItem

// string key = 1;
inline void StateItem::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& StateItem::key() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.StateItem.key)
  return key_.GetNoArena();
}
inline void StateItem::set_key(const ::std::string& value) {
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.StateItem.key)
}
#if LANG_CXX11
inline void StateItem::set_key(::std::string&& value) {
  
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.StateItem.key)
}
#endif
inline void StateItem::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.StateItem.key)
}
inline void StateItem::set_key(const char* value, size_t size) {
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.StateItem.key)
}
inline ::std::string* StateItem::mutable_key() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.StateItem.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StateItem::release_key() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.StateItem.key)
  
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StateItem::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    
  } else {
    
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.StateItem.key)
}

// bytes value = 2;
inline void StateItem::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& StateItem::value() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.StateItem.value)
  return value_.GetNoArena();
}
inline void StateItem::set_value(const ::std::string& value) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.StateItem.value)
}
#if LANG_CXX11
inline void StateItem::set_value(::std::string&& value) {
  
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.StateItem.value)
}
#endif
inline void StateItem::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.StateItem.value)
}
inline void StateItem::set_value(const void* value, size_t size) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.StateItem.value)
}
inline ::std::string* StateItem::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.StateItem.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* StateItem::release_value() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.StateItem.value)
  
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void StateItem::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    
  } else {
    
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.StateItem.value)
}

// .dapr.proto.common.v1.Etag etag = 3;
inline bool StateItem::has_etag() const {
  return this != internal_default_instance() && etag_ != NULL;
}
inline void StateItem::clear_etag() {
  if (GetArenaNoVirtual() == NULL && etag_ != NULL) {
    delete etag_;
  }
  etag_ = NULL;
}
inline const ::dapr::proto::common::v1::Etag& StateItem::_internal_etag() const {
  return *etag_;
}
inline const ::dapr::proto::common::v1::Etag& StateItem::etag() const {
  const ::dapr::proto::common::v1::Etag* p = etag_;
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.StateItem.etag)
  return p != NULL ? *p : *reinterpret_cast<const ::dapr::proto::common::v1::Etag*>(
      &::dapr::proto::common::v1::_Etag_default_instance_);
}
inline ::dapr::proto::common::v1::Etag* StateItem::release_etag() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.StateItem.etag)
  
  ::dapr::proto::common::v1::Etag* temp = etag_;
  etag_ = NULL;
  return temp;
}
inline ::dapr::proto::common::v1::Etag* StateItem::mutable_etag() {
  
  if (etag_ == NULL) {
    auto* p = CreateMaybeMessage<::dapr::proto::common::v1::Etag>(GetArenaNoVirtual());
    etag_ = p;
  }
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.StateItem.etag)
  return etag_;
}
inline void StateItem::set_allocated_etag(::dapr::proto::common::v1::Etag* etag) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete etag_;
  }
  if (etag) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      etag = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, etag, submessage_arena);
    }
    
  } else {
    
  }
  etag_ = etag;
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.StateItem.etag)
}

// map<string, string> metadata = 4;
inline int StateItem::metadata_size() const {
  return metadata_.size();
}
inline void StateItem::clear_metadata() {
  metadata_.Clear();
}
inline const ::google::protobuf::Map< ::std::string, ::std::string >&
StateItem::metadata() const {
  // @@protoc_insertion_point(field_map:dapr.proto.common.v1.StateItem.metadata)
  return metadata_.GetMap();
}
inline ::google::protobuf::Map< ::std::string, ::std::string >*
StateItem::mutable_metadata() {
  // @@protoc_insertion_point(field_mutable_map:dapr.proto.common.v1.StateItem.metadata)
  return metadata_.MutableMap();
}

// .dapr.proto.common.v1.StateOptions options = 5;
inline bool StateItem::has_options() const {
  return this != internal_default_instance() && options_ != NULL;
}
inline void StateItem::clear_options() {
  if (GetArenaNoVirtual() == NULL && options_ != NULL) {
    delete options_;
  }
  options_ = NULL;
}
inline const ::dapr::proto::common::v1::StateOptions& StateItem::_internal_options() const {
  return *options_;
}
inline const ::dapr::proto::common::v1::StateOptions& StateItem::options() const {
  const ::dapr::proto::common::v1::StateOptions* p = options_;
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.StateItem.options)
  return p != NULL ? *p : *reinterpret_cast<const ::dapr::proto::common::v1::StateOptions*>(
      &::dapr::proto::common::v1::_StateOptions_default_instance_);
}
inline ::dapr::proto::common::v1::StateOptions* StateItem::release_options() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.StateItem.options)
  
  ::dapr::proto::common::v1::StateOptions* temp = options_;
  options_ = NULL;
  return temp;
}
inline ::dapr::proto::common::v1::StateOptions* StateItem::mutable_options() {
  
  if (options_ == NULL) {
    auto* p = CreateMaybeMessage<::dapr::proto::common::v1::StateOptions>(GetArenaNoVirtual());
    options_ = p;
  }
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.StateItem.options)
  return options_;
}
inline void StateItem::set_allocated_options(::dapr::proto::common::v1::StateOptions* options) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete options_;
  }
  if (options) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      options = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, options, submessage_arena);
    }
    
  } else {
    
  }
  options_ = options;
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.StateItem.options)
}

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

// Etag

// string value = 1;
inline void Etag::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Etag::value() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.Etag.value)
  return value_.GetNoArena();
}
inline void Etag::set_value(const ::std::string& value) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.Etag.value)
}
#if LANG_CXX11
inline void Etag::set_value(::std::string&& value) {
  
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.Etag.value)
}
#endif
inline void Etag::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.Etag.value)
}
inline void Etag::set_value(const char* value, size_t size) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.Etag.value)
}
inline ::std::string* Etag::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.Etag.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Etag::release_value() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.Etag.value)
  
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Etag::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    
  } else {
    
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.Etag.value)
}

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

// StateOptions

// .dapr.proto.common.v1.StateOptions.StateConcurrency concurrency = 1;
inline void StateOptions::clear_concurrency() {
  concurrency_ = 0;
}
inline ::dapr::proto::common::v1::StateOptions_StateConcurrency StateOptions::concurrency() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.StateOptions.concurrency)
  return static_cast< ::dapr::proto::common::v1::StateOptions_StateConcurrency >(concurrency_);
}
inline void StateOptions::set_concurrency(::dapr::proto::common::v1::StateOptions_StateConcurrency value) {
  
  concurrency_ = value;
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.StateOptions.concurrency)
}

// .dapr.proto.common.v1.StateOptions.StateConsistency consistency = 2;
inline void StateOptions::clear_consistency() {
  consistency_ = 0;
}
inline ::dapr::proto::common::v1::StateOptions_StateConsistency StateOptions::consistency() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.StateOptions.consistency)
  return static_cast< ::dapr::proto::common::v1::StateOptions_StateConsistency >(consistency_);
}
inline void StateOptions::set_consistency(::dapr::proto::common::v1::StateOptions_StateConsistency value) {
  
  consistency_ = value;
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.StateOptions.consistency)
}

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

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

// ConfigurationItem

// string key = 1;
inline void ConfigurationItem::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ConfigurationItem::key() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.ConfigurationItem.key)
  return key_.GetNoArena();
}
inline void ConfigurationItem::set_key(const ::std::string& value) {
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.ConfigurationItem.key)
}
#if LANG_CXX11
inline void ConfigurationItem::set_key(::std::string&& value) {
  
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.ConfigurationItem.key)
}
#endif
inline void ConfigurationItem::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.ConfigurationItem.key)
}
inline void ConfigurationItem::set_key(const char* value, size_t size) {
  
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.ConfigurationItem.key)
}
inline ::std::string* ConfigurationItem::mutable_key() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.ConfigurationItem.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ConfigurationItem::release_key() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.ConfigurationItem.key)
  
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ConfigurationItem::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    
  } else {
    
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.ConfigurationItem.key)
}

// string value = 2;
inline void ConfigurationItem::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ConfigurationItem::value() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.ConfigurationItem.value)
  return value_.GetNoArena();
}
inline void ConfigurationItem::set_value(const ::std::string& value) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.ConfigurationItem.value)
}
#if LANG_CXX11
inline void ConfigurationItem::set_value(::std::string&& value) {
  
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.ConfigurationItem.value)
}
#endif
inline void ConfigurationItem::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.ConfigurationItem.value)
}
inline void ConfigurationItem::set_value(const char* value, size_t size) {
  
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.ConfigurationItem.value)
}
inline ::std::string* ConfigurationItem::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.ConfigurationItem.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ConfigurationItem::release_value() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.ConfigurationItem.value)
  
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ConfigurationItem::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    
  } else {
    
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.ConfigurationItem.value)
}

// string version = 3;
inline void ConfigurationItem::clear_version() {
  version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ConfigurationItem::version() const {
  // @@protoc_insertion_point(field_get:dapr.proto.common.v1.ConfigurationItem.version)
  return version_.GetNoArena();
}
inline void ConfigurationItem::set_version(const ::std::string& value) {
  
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dapr.proto.common.v1.ConfigurationItem.version)
}
#if LANG_CXX11
inline void ConfigurationItem::set_version(::std::string&& value) {
  
  version_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dapr.proto.common.v1.ConfigurationItem.version)
}
#endif
inline void ConfigurationItem::set_version(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dapr.proto.common.v1.ConfigurationItem.version)
}
inline void ConfigurationItem::set_version(const char* value, size_t size) {
  
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dapr.proto.common.v1.ConfigurationItem.version)
}
inline ::std::string* ConfigurationItem::mutable_version() {
  
  // @@protoc_insertion_point(field_mutable:dapr.proto.common.v1.ConfigurationItem.version)
  return version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ConfigurationItem::release_version() {
  // @@protoc_insertion_point(field_release:dapr.proto.common.v1.ConfigurationItem.version)
  
  return version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ConfigurationItem::set_allocated_version(::std::string* version) {
  if (version != NULL) {
    
  } else {
    
  }
  version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), version);
  // @@protoc_insertion_point(field_set_allocated:dapr.proto.common.v1.ConfigurationItem.version)
}

// map<string, string> metadata = 4;
inline int ConfigurationItem::metadata_size() const {
  return metadata_.size();
}
inline void ConfigurationItem::clear_metadata() {
  metadata_.Clear();
}
inline const ::google::protobuf::Map< ::std::string, ::std::string >&
ConfigurationItem::metadata() const {
  // @@protoc_insertion_point(field_map:dapr.proto.common.v1.ConfigurationItem.metadata)
  return metadata_.GetMap();
}
inline ::google::protobuf::Map< ::std::string, ::std::string >*
ConfigurationItem::mutable_metadata() {
  // @@protoc_insertion_point(field_mutable_map:dapr.proto.common.v1.ConfigurationItem.metadata)
  return metadata_.MutableMap();
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace v1
}  // namespace common
}  // namespace proto
}  // namespace dapr

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::dapr::proto::common::v1::HTTPExtension_Verb> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dapr::proto::common::v1::HTTPExtension_Verb>() {
  return ::dapr::proto::common::v1::HTTPExtension_Verb_descriptor();
}
template <> struct is_proto_enum< ::dapr::proto::common::v1::StateOptions_StateConcurrency> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dapr::proto::common::v1::StateOptions_StateConcurrency>() {
  return ::dapr::proto::common::v1::StateOptions_StateConcurrency_descriptor();
}
template <> struct is_proto_enum< ::dapr::proto::common::v1::StateOptions_StateConsistency> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dapr::proto::common::v1::StateOptions_StateConsistency>() {
  return ::dapr::proto::common::v1::StateOptions_StateConsistency_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_dapr_2fproto_2fcommon_2fv1_2fcommon_2eproto
