text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: common.proto
  
  #ifndef GOOGLE_PROTOBUF_INCLUDED_common_2eproto
  #define GOOGLE_PROTOBUF_INCLUDED_common_2eproto
  
  #include <limits>
  #include <string>
  
  #include <google/protobuf/port_def.inc>
  #if PROTOBUF_VERSION < 3009000
  #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 3009000 < 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/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_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/generated_message_reflection.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/generated_enum_reflection.h>
  #include <google/protobuf/unknown_field_set.h>
  // @@protoc_insertion_point(includes)
  #include <google/protobuf/port_def.inc>
  #define PROTOBUF_INTERNAL_EXPORT_common_2eproto
  PROTOBUF_NAMESPACE_OPEN
  namespace internal {
  class AnyMetadata;
  }  // namespace internal
  PROTOBUF_NAMESPACE_CLOSE
  
  // Internal implementation detail -- do not use these members.
  struct TableStruct_common_2eproto {
    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[8]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
    static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
    static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
  };
  extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto;
  namespace milvus {
  namespace proto {
  namespace common {
  class Address;
  class AddressDefaultTypeInternal;
  extern AddressDefaultTypeInternal _Address_default_instance_;
  class Blob;
  class BlobDefaultTypeInternal;
  extern BlobDefaultTypeInternal _Blob_default_instance_;
  class DMLMsgHeader;
  class DMLMsgHeaderDefaultTypeInternal;
  extern DMLMsgHeaderDefaultTypeInternal _DMLMsgHeader_default_instance_;
  class KeyDataPair;
  class KeyDataPairDefaultTypeInternal;
  extern KeyDataPairDefaultTypeInternal _KeyDataPair_default_instance_;
  class KeyValuePair;
  class KeyValuePairDefaultTypeInternal;
  extern KeyValuePairDefaultTypeInternal _KeyValuePair_default_instance_;
  class MsgBase;
  class MsgBaseDefaultTypeInternal;
  extern MsgBaseDefaultTypeInternal _MsgBase_default_instance_;
  class MsgHeader;
  class MsgHeaderDefaultTypeInternal;
  extern MsgHeaderDefaultTypeInternal _MsgHeader_default_instance_;
  class Status;
  class StatusDefaultTypeInternal;
  extern StatusDefaultTypeInternal _Status_default_instance_;
  }  // namespace common
  }  // namespace proto
  }  // namespace milvus
  PROTOBUF_NAMESPACE_OPEN
  template<> ::milvus::proto::common::Address* Arena::CreateMaybeMessage<::milvus::proto::common::Address>(Arena*);
  template<> ::milvus::proto::common::Blob* Arena::CreateMaybeMessage<::milvus::proto::common::Blob>(Arena*);
  template<> ::milvus::proto::common::DMLMsgHeader* Arena::CreateMaybeMessage<::milvus::proto::common::DMLMsgHeader>(Arena*);
  template<> ::milvus::proto::common::KeyDataPair* Arena::CreateMaybeMessage<::milvus::proto::common::KeyDataPair>(Arena*);
  template<> ::milvus::proto::common::KeyValuePair* Arena::CreateMaybeMessage<::milvus::proto::common::KeyValuePair>(Arena*);
  template<> ::milvus::proto::common::MsgBase* Arena::CreateMaybeMessage<::milvus::proto::common::MsgBase>(Arena*);
  template<> ::milvus::proto::common::MsgHeader* Arena::CreateMaybeMessage<::milvus::proto::common::MsgHeader>(Arena*);
  template<> ::milvus::proto::common::Status* Arena::CreateMaybeMessage<::milvus::proto::common::Status>(Arena*);
  PROTOBUF_NAMESPACE_CLOSE
  namespace milvus {
  namespace proto {
  namespace common {
  
  enum ErrorCode : int {
    Success = 0,
    UnexpectedError = 1,
    ConnectFailed = 2,
    PermissionDenied = 3,
    CollectionNotExists = 4,
    IllegalArgument = 5,
    IllegalDimension = 7,
    IllegalIndexType = 8,
    IllegalCollectionName = 9,
    IllegalTOPK = 10,
    IllegalRowRecord = 11,
    IllegalVectorID = 12,
    IllegalSearchResult = 13,
    FileNotFound = 14,
    MetaFailed = 15,
    CacheFailed = 16,
    CannotCreateFolder = 17,
    CannotCreateFile = 18,
    CannotDeleteFolder = 19,
    CannotDeleteFile = 20,
    BuildIndexError = 21,
    IllegalNLIST = 22,
    IllegalMetricType = 23,
    OutOfMemory = 24,
    IndexNotExist = 25,
    EmptyCollection = 26,
    UpdateImportTaskFailure = 27,
    CollectionNameNotFound = 28,
    CreateCredentialFailure = 29,
    UpdateCredentialFailure = 30,
    DeleteCredentialFailure = 31,
    GetCredentialFailure = 32,
    ListCredUsersFailure = 33,
    DDRequestRace = 1000,
    ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool ErrorCode_IsValid(int value);
  constexpr ErrorCode ErrorCode_MIN = Success;
  constexpr ErrorCode ErrorCode_MAX = DDRequestRace;
  constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor();
  template<typename T>
  inline const std::string& ErrorCode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ErrorCode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ErrorCode_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      ErrorCode_descriptor(), enum_t_value);
  }
  inline bool ErrorCode_Parse(
      const std::string& name, ErrorCode* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ErrorCode>(
      ErrorCode_descriptor(), name, value);
  }
  enum IndexState : int {
    IndexStateNone = 0,
    Unissued = 1,
    InProgress = 2,
    Finished = 3,
    Failed = 4,
    IndexState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    IndexState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool IndexState_IsValid(int value);
  constexpr IndexState IndexState_MIN = IndexStateNone;
  constexpr IndexState IndexState_MAX = Failed;
  constexpr int IndexState_ARRAYSIZE = IndexState_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* IndexState_descriptor();
  template<typename T>
  inline const std::string& IndexState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, IndexState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function IndexState_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      IndexState_descriptor(), enum_t_value);
  }
  inline bool IndexState_Parse(
      const std::string& name, IndexState* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<IndexState>(
      IndexState_descriptor(), name, value);
  }
  enum SegmentState : int {
    SegmentStateNone = 0,
    NotExist = 1,
    Growing = 2,
    Sealed = 3,
    Flushed = 4,
    Flushing = 5,
    Dropped = 6,
    Importing = 7,
    SegmentState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    SegmentState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool SegmentState_IsValid(int value);
  constexpr SegmentState SegmentState_MIN = SegmentStateNone;
  constexpr SegmentState SegmentState_MAX = Importing;
  constexpr int SegmentState_ARRAYSIZE = SegmentState_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SegmentState_descriptor();
  template<typename T>
  inline const std::string& SegmentState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SegmentState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SegmentState_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      SegmentState_descriptor(), enum_t_value);
  }
  inline bool SegmentState_Parse(
      const std::string& name, SegmentState* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SegmentState>(
      SegmentState_descriptor(), name, value);
  }
  enum MsgType : int {
    Undefined = 0,
    CreateCollection = 100,
    DropCollection = 101,
    HasCollection = 102,
    DescribeCollection = 103,
    ShowCollections = 104,
    GetSystemConfigs = 105,
    LoadCollection = 106,
    ReleaseCollection = 107,
    CreateAlias = 108,
    DropAlias = 109,
    AlterAlias = 110,
    CreatePartition = 200,
    DropPartition = 201,
    HasPartition = 202,
    DescribePartition = 203,
    ShowPartitions = 204,
    LoadPartitions = 205,
    ReleasePartitions = 206,
    ShowSegments = 250,
    DescribeSegment = 251,
    LoadSegments = 252,
    ReleaseSegments = 253,
    HandoffSegments = 254,
    LoadBalanceSegments = 255,
    DescribeSegments = 256,
    CreateIndex = 300,
    DescribeIndex = 301,
    DropIndex = 302,
    Insert = 400,
    Delete = 401,
    Flush = 402,
    Search = 500,
    SearchResult = 501,
    GetIndexState = 502,
    GetIndexBuildProgress = 503,
    GetCollectionStatistics = 504,
    GetPartitionStatistics = 505,
    Retrieve = 506,
    RetrieveResult = 507,
    WatchDmChannels = 508,
    RemoveDmChannels = 509,
    WatchQueryChannels = 510,
    RemoveQueryChannels = 511,
    SealedSegmentsChangeInfo = 512,
    WatchDeltaChannels = 513,
    GetShardLeaders = 514,
    GetReplicas = 515,
    SegmentInfo = 600,
    SystemInfo = 601,
    GetRecoveryInfo = 602,
    GetSegmentState = 603,
    TimeTick = 1200,
    QueryNodeStats = 1201,
    LoadIndex = 1202,
    RequestID = 1203,
    RequestTSO = 1204,
    AllocateSegment = 1205,
    SegmentStatistics = 1206,
    SegmentFlushDone = 1207,
    DataNodeTt = 1208,
    CreateCredential = 1500,
    GetCredential = 1501,
    DeleteCredential = 1502,
    UpdateCredential = 1503,
    ListCredUsernames = 1504,
    MsgType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    MsgType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool MsgType_IsValid(int value);
  constexpr MsgType MsgType_MIN = Undefined;
  constexpr MsgType MsgType_MAX = ListCredUsernames;
  constexpr int MsgType_ARRAYSIZE = MsgType_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MsgType_descriptor();
  template<typename T>
  inline const std::string& MsgType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MsgType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MsgType_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      MsgType_descriptor(), enum_t_value);
  }
  inline bool MsgType_Parse(
      const std::string& name, MsgType* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MsgType>(
      MsgType_descriptor(), name, value);
  }
  enum DslType : int {
    Dsl = 0,
    BoolExprV1 = 1,
    DslType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    DslType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool DslType_IsValid(int value);
  constexpr DslType DslType_MIN = Dsl;
  constexpr DslType DslType_MAX = BoolExprV1;
  constexpr int DslType_ARRAYSIZE = DslType_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DslType_descriptor();
  template<typename T>
  inline const std::string& DslType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DslType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DslType_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      DslType_descriptor(), enum_t_value);
  }
  inline bool DslType_Parse(
      const std::string& name, DslType* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DslType>(
      DslType_descriptor(), name, value);
  }
  enum CompactionState : int {
    UndefiedState = 0,
    Executing = 1,
    Completed = 2,
    CompactionState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    CompactionState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool CompactionState_IsValid(int value);
  constexpr CompactionState CompactionState_MIN = UndefiedState;
  constexpr CompactionState CompactionState_MAX = Completed;
  constexpr int CompactionState_ARRAYSIZE = CompactionState_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompactionState_descriptor();
  template<typename T>
  inline const std::string& CompactionState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, CompactionState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function CompactionState_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      CompactionState_descriptor(), enum_t_value);
  }
  inline bool CompactionState_Parse(
      const std::string& name, CompactionState* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CompactionState>(
      CompactionState_descriptor(), name, value);
  }
  enum ConsistencyLevel : int {
    Strong = 0,
    Session = 1,
    Bounded = 2,
    Eventually = 3,
    Customized = 4,
    ConsistencyLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    ConsistencyLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool ConsistencyLevel_IsValid(int value);
  constexpr ConsistencyLevel ConsistencyLevel_MIN = Strong;
  constexpr ConsistencyLevel ConsistencyLevel_MAX = Customized;
  constexpr int ConsistencyLevel_ARRAYSIZE = ConsistencyLevel_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConsistencyLevel_descriptor();
  template<typename T>
  inline const std::string& ConsistencyLevel_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ConsistencyLevel>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ConsistencyLevel_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      ConsistencyLevel_descriptor(), enum_t_value);
  }
  inline bool ConsistencyLevel_Parse(
      const std::string& name, ConsistencyLevel* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConsistencyLevel>(
      ConsistencyLevel_descriptor(), name, value);
  }
  enum ImportState : int {
    ImportPending = 0,
    ImportFailed = 1,
    ImportStarted = 2,
    ImportDownloaded = 3,
    ImportParsed = 4,
    ImportPersisted = 5,
    ImportCompleted = 6,
    ImportState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    ImportState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool ImportState_IsValid(int value);
  constexpr ImportState ImportState_MIN = ImportPending;
  constexpr ImportState ImportState_MAX = ImportCompleted;
  constexpr int ImportState_ARRAYSIZE = ImportState_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ImportState_descriptor();
  template<typename T>
  inline const std::string& ImportState_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ImportState>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ImportState_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      ImportState_descriptor(), enum_t_value);
  }
  inline bool ImportState_Parse(
      const std::string& name, ImportState* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ImportState>(
      ImportState_descriptor(), name, value);
  }
  // ===================================================================
  
  class Status :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Status) */ {
   public:
    Status();
    virtual ~Status();
  
    Status(const Status& from);
    Status(Status&& from) noexcept
      : Status() {
      *this = ::std::move(from);
    }
  
    inline Status& operator=(const Status& from) {
      CopyFrom(from);
      return *this;
    }
    inline Status& operator=(Status&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return GetMetadataStatic().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return GetMetadataStatic().reflection;
    }
    static const Status& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Status* internal_default_instance() {
      return reinterpret_cast<const Status*>(
                 &_Status_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      0;
  
    friend void swap(Status& a, Status& b) {
      a.Swap(&b);
    }
    inline void Swap(Status* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline Status* New() const final {
      return CreateMaybeMessage<Status>(nullptr);
    }
  
    Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<Status>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const Status& from);
    void MergeFrom(const Status& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    #else
    bool MergePartialFromCodedStream(
        ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
    ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
        ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    inline void SharedCtor();
    inline void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(Status* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.proto.common.Status";
    }
    private:
    inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
    private:
    static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
      return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kReasonFieldNumber = 2,
      kErrorCodeFieldNumber = 1,
    };
    // string reason = 2;
    void clear_reason();
    const std::string& reason() const;
    void set_reason(const std::string& value);
    void set_reason(std::string&& value);
    void set_reason(const char* value);
    void set_reason(const char* value, size_t size);
    std::string* mutable_reason();
    std::string* release_reason();
    void set_allocated_reason(std::string* reason);
  
    // .milvus.proto.common.ErrorCode error_code = 1;
    void clear_error_code();
    ::milvus::proto::common::ErrorCode error_code() const;
    void set_error_code(::milvus::proto::common::ErrorCode value);
  
    // @@protoc_insertion_point(class_scope:milvus.proto.common.Status)
   private:
    class _Internal;
  
    ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_;
    int error_code_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2eproto;
  };
  // -------------------------------------------------------------------
  
  class KeyValuePair :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.KeyValuePair) */ {
   public:
    KeyValuePair();
    virtual ~KeyValuePair();
  
    KeyValuePair(const KeyValuePair& from);
    KeyValuePair(KeyValuePair&& from) noexcept
      : KeyValuePair() {
      *this = ::std::move(from);
    }
  
    inline KeyValuePair& operator=(const KeyValuePair& from) {
      CopyFrom(from);
      return *this;
    }
    inline KeyValuePair& operator=(KeyValuePair&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return GetMetadataStatic().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return GetMetadataStatic().reflection;
    }
    static const KeyValuePair& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const KeyValuePair* internal_default_instance() {
      return reinterpret_cast<const KeyValuePair*>(
                 &_KeyValuePair_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      1;
  
    friend void swap(KeyValuePair& a, KeyValuePair& b) {
      a.Swap(&b);
    }
    inline void Swap(KeyValuePair* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline KeyValuePair* New() const final {
      return CreateMaybeMessage<KeyValuePair>(nullptr);
    }
  
    KeyValuePair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<KeyValuePair>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const KeyValuePair& from);
    void MergeFrom(const KeyValuePair& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    #else
    bool MergePartialFromCodedStream(
        ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
    ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
        ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    inline void SharedCtor();
    inline void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(KeyValuePair* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.proto.common.KeyValuePair";
    }
    private:
    inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
    private:
    static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
      return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kKeyFieldNumber = 1,
      kValueFieldNumber = 2,
    };
    // string key = 1;
    void clear_key();
    const std::string& key() const;
    void set_key(const std::string& value);
    void set_key(std::string&& value);
    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();
    const std::string& value() const;
    void set_value(const std::string& value);
    void set_value(std::string&& value);
    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:milvus.proto.common.KeyValuePair)
   private:
    class _Internal;
  
    ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2eproto;
  };
  // -------------------------------------------------------------------
  
  class KeyDataPair :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.KeyDataPair) */ {
   public:
    KeyDataPair();
    virtual ~KeyDataPair();
  
    KeyDataPair(const KeyDataPair& from);
    KeyDataPair(KeyDataPair&& from) noexcept
      : KeyDataPair() {
      *this = ::std::move(from);
    }
  
    inline KeyDataPair& operator=(const KeyDataPair& from) {
      CopyFrom(from);
      return *this;
    }
    inline KeyDataPair& operator=(KeyDataPair&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return GetMetadataStatic().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return GetMetadataStatic().reflection;
    }
    static const KeyDataPair& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const KeyDataPair* internal_default_instance() {
      return reinterpret_cast<const KeyDataPair*>(
                 &_KeyDataPair_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      2;
  
    friend void swap(KeyDataPair& a, KeyDataPair& b) {
      a.Swap(&b);
    }
    inline void Swap(KeyDataPair* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline KeyDataPair* New() const final {
      return CreateMaybeMessage<KeyDataPair>(nullptr);
    }
  
    KeyDataPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<KeyDataPair>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const KeyDataPair& from);
    void MergeFrom(const KeyDataPair& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    #else
    bool MergePartialFromCodedStream(
        ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
    ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
        ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    inline void SharedCtor();
    inline void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(KeyDataPair* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.proto.common.KeyDataPair";
    }
    private:
    inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
    private:
    static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
      return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kKeyFieldNumber = 1,
      kDataFieldNumber = 2,
    };
    // string key = 1;
    void clear_key();
    const std::string& key() const;
    void set_key(const std::string& value);
    void set_key(std::string&& value);
    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 data = 2;
    void clear_data();
    const std::string& data() const;
    void set_data(const std::string& value);
    void set_data(std::string&& value);
    void set_data(const char* value);
    void set_data(const void* value, size_t size);
    std::string* mutable_data();
    std::string* release_data();
    void set_allocated_data(std::string* data);
  
    // @@protoc_insertion_point(class_scope:milvus.proto.common.KeyDataPair)
   private:
    class _Internal;
  
    ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2eproto;
  };
  // -------------------------------------------------------------------
  
  class Blob :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Blob) */ {
   public:
    Blob();
    virtual ~Blob();
  
    Blob(const Blob& from);
    Blob(Blob&& from) noexcept
      : Blob() {
      *this = ::std::move(from);
    }
  
    inline Blob& operator=(const Blob& from) {
      CopyFrom(from);
      return *this;
    }
    inline Blob& operator=(Blob&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return GetMetadataStatic().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return GetMetadataStatic().reflection;
    }
    static const Blob& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Blob* internal_default_instance() {
      return reinterpret_cast<const Blob*>(
                 &_Blob_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      3;
  
    friend void swap(Blob& a, Blob& b) {
      a.Swap(&b);
    }
    inline void Swap(Blob* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline Blob* New() const final {
      return CreateMaybeMessage<Blob>(nullptr);
    }
  
    Blob* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<Blob>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const Blob& from);
    void MergeFrom(const Blob& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    #else
    bool MergePartialFromCodedStream(
        ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
    ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
        ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    inline void SharedCtor();
    inline void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(Blob* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.proto.common.Blob";
    }
    private:
    inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
    private:
    static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
      return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kValueFieldNumber = 1,
    };
    // bytes value = 1;
    void clear_value();
    const std::string& value() const;
    void set_value(const std::string& value);
    void set_value(std::string&& value);
    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);
  
    // @@protoc_insertion_point(class_scope:milvus.proto.common.Blob)
   private:
    class _Internal;
  
    ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2eproto;
  };
  // -------------------------------------------------------------------
  
  class Address :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Address) */ {
   public:
    Address();
    virtual ~Address();
  
    Address(const Address& from);
    Address(Address&& from) noexcept
      : Address() {
      *this = ::std::move(from);
    }
  
    inline Address& operator=(const Address& from) {
      CopyFrom(from);
      return *this;
    }
    inline Address& operator=(Address&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return GetMetadataStatic().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return GetMetadataStatic().reflection;
    }
    static const Address& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Address* internal_default_instance() {
      return reinterpret_cast<const Address*>(
                 &_Address_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      4;
  
    friend void swap(Address& a, Address& b) {
      a.Swap(&b);
    }
    inline void Swap(Address* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline Address* New() const final {
      return CreateMaybeMessage<Address>(nullptr);
    }
  
    Address* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<Address>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const Address& from);
    void MergeFrom(const Address& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    #else
    bool MergePartialFromCodedStream(
        ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
    ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
        ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    inline void SharedCtor();
    inline void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(Address* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.proto.common.Address";
    }
    private:
    inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
    private:
    static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
      return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kIpFieldNumber = 1,
      kPortFieldNumber = 2,
    };
    // string ip = 1;
    void clear_ip();
    const std::string& ip() const;
    void set_ip(const std::string& value);
    void set_ip(std::string&& value);
    void set_ip(const char* value);
    void set_ip(const char* value, size_t size);
    std::string* mutable_ip();
    std::string* release_ip();
    void set_allocated_ip(std::string* ip);
  
    // int64 port = 2;
    void clear_port();
    ::PROTOBUF_NAMESPACE_ID::int64 port() const;
    void set_port(::PROTOBUF_NAMESPACE_ID::int64 value);
  
    // @@protoc_insertion_point(class_scope:milvus.proto.common.Address)
   private:
    class _Internal;
  
    ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
    ::PROTOBUF_NAMESPACE_ID::int64 port_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2eproto;
  };
  // -------------------------------------------------------------------
  
  class MsgBase :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.MsgBase) */ {
   public:
    MsgBase();
    virtual ~MsgBase();
  
    MsgBase(const MsgBase& from);
    MsgBase(MsgBase&& from) noexcept
      : MsgBase() {
      *this = ::std::move(from);
    }
  
    inline MsgBase& operator=(const MsgBase& from) {
      CopyFrom(from);
      return *this;
    }
    inline MsgBase& operator=(MsgBase&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return GetMetadataStatic().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return GetMetadataStatic().reflection;
    }
    static const MsgBase& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const MsgBase* internal_default_instance() {
      return reinterpret_cast<const MsgBase*>(
                 &_MsgBase_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      5;
  
    friend void swap(MsgBase& a, MsgBase& b) {
      a.Swap(&b);
    }
    inline void Swap(MsgBase* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline MsgBase* New() const final {
      return CreateMaybeMessage<MsgBase>(nullptr);
    }
  
    MsgBase* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<MsgBase>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const MsgBase& from);
    void MergeFrom(const MsgBase& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    #else
    bool MergePartialFromCodedStream(
        ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
    ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
        ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    inline void SharedCtor();
    inline void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(MsgBase* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.proto.common.MsgBase";
    }
    private:
    inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
    private:
    static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
      return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kMsgIDFieldNumber = 2,
      kTimestampFieldNumber = 3,
      kSourceIDFieldNumber = 4,
      kMsgTypeFieldNumber = 1,
    };
    // int64 msgID = 2;
    void clear_msgid();
    ::PROTOBUF_NAMESPACE_ID::int64 msgid() const;
    void set_msgid(::PROTOBUF_NAMESPACE_ID::int64 value);
  
    // uint64 timestamp = 3;
    void clear_timestamp();
    ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const;
    void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);
  
    // int64 sourceID = 4;
    void clear_sourceid();
    ::PROTOBUF_NAMESPACE_ID::int64 sourceid() const;
    void set_sourceid(::PROTOBUF_NAMESPACE_ID::int64 value);
  
    // .milvus.proto.common.MsgType msg_type = 1;
    void clear_msg_type();
    ::milvus::proto::common::MsgType msg_type() const;
    void set_msg_type(::milvus::proto::common::MsgType value);
  
    // @@protoc_insertion_point(class_scope:milvus.proto.common.MsgBase)
   private:
    class _Internal;
  
    ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
    ::PROTOBUF_NAMESPACE_ID::int64 msgid_;
    ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
    ::PROTOBUF_NAMESPACE_ID::int64 sourceid_;
    int msg_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2eproto;
  };
  // -------------------------------------------------------------------
  
  class MsgHeader :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.MsgHeader) */ {
   public:
    MsgHeader();
    virtual ~MsgHeader();
  
    MsgHeader(const MsgHeader& from);
    MsgHeader(MsgHeader&& from) noexcept
      : MsgHeader() {
      *this = ::std::move(from);
    }
  
    inline MsgHeader& operator=(const MsgHeader& from) {
      CopyFrom(from);
      return *this;
    }
    inline MsgHeader& operator=(MsgHeader&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return GetMetadataStatic().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return GetMetadataStatic().reflection;
    }
    static const MsgHeader& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const MsgHeader* internal_default_instance() {
      return reinterpret_cast<const MsgHeader*>(
                 &_MsgHeader_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      6;
  
    friend void swap(MsgHeader& a, MsgHeader& b) {
      a.Swap(&b);
    }
    inline void Swap(MsgHeader* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline MsgHeader* New() const final {
      return CreateMaybeMessage<MsgHeader>(nullptr);
    }
  
    MsgHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<MsgHeader>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const MsgHeader& from);
    void MergeFrom(const MsgHeader& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    #else
    bool MergePartialFromCodedStream(
        ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
    ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
        ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    inline void SharedCtor();
    inline void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(MsgHeader* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.proto.common.MsgHeader";
    }
    private:
    inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
    private:
    static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
      return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kBaseFieldNumber = 1,
    };
    // .milvus.proto.common.MsgBase base = 1;
    bool has_base() const;
    void clear_base();
    const ::milvus::proto::common::MsgBase& base() const;
    ::milvus::proto::common::MsgBase* release_base();
    ::milvus::proto::common::MsgBase* mutable_base();
    void set_allocated_base(::milvus::proto::common::MsgBase* base);
  
    // @@protoc_insertion_point(class_scope:milvus.proto.common.MsgHeader)
   private:
    class _Internal;
  
    ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
    ::milvus::proto::common::MsgBase* base_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2eproto;
  };
  // -------------------------------------------------------------------
  
  class DMLMsgHeader :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.DMLMsgHeader) */ {
   public:
    DMLMsgHeader();
    virtual ~DMLMsgHeader();
  
    DMLMsgHeader(const DMLMsgHeader& from);
    DMLMsgHeader(DMLMsgHeader&& from) noexcept
      : DMLMsgHeader() {
      *this = ::std::move(from);
    }
  
    inline DMLMsgHeader& operator=(const DMLMsgHeader& from) {
      CopyFrom(from);
      return *this;
    }
    inline DMLMsgHeader& operator=(DMLMsgHeader&& from) noexcept {
      if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
        if (this != &from) InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return GetMetadataStatic().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return GetMetadataStatic().reflection;
    }
    static const DMLMsgHeader& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const DMLMsgHeader* internal_default_instance() {
      return reinterpret_cast<const DMLMsgHeader*>(
                 &_DMLMsgHeader_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      7;
  
    friend void swap(DMLMsgHeader& a, DMLMsgHeader& b) {
      a.Swap(&b);
    }
    inline void Swap(DMLMsgHeader* other) {
      if (other == this) return;
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline DMLMsgHeader* New() const final {
      return CreateMaybeMessage<DMLMsgHeader>(nullptr);
    }
  
    DMLMsgHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<DMLMsgHeader>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const DMLMsgHeader& from);
    void MergeFrom(const DMLMsgHeader& from);
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    #else
    bool MergePartialFromCodedStream(
        ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
    #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
    void SerializeWithCachedSizes(
        ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
    ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
        ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    inline void SharedCtor();
    inline void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(DMLMsgHeader* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "milvus.proto.common.DMLMsgHeader";
    }
    private:
    inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
      return nullptr;
    }
    inline void* MaybeArenaPtr() const {
      return nullptr;
    }
    public:
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
    private:
    static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2eproto);
      return ::descriptor_table_common_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kShardNameFieldNumber = 2,
      kBaseFieldNumber = 1,
    };
    // string shardName = 2;
    void clear_shardname();
    const std::string& shardname() const;
    void set_shardname(const std::string& value);
    void set_shardname(std::string&& value);
    void set_shardname(const char* value);
    void set_shardname(const char* value, size_t size);
    std::string* mutable_shardname();
    std::string* release_shardname();
    void set_allocated_shardname(std::string* shardname);
  
    // .milvus.proto.common.MsgBase base = 1;
    bool has_base() const;
    void clear_base();
    const ::milvus::proto::common::MsgBase& base() const;
    ::milvus::proto::common::MsgBase* release_base();
    ::milvus::proto::common::MsgBase* mutable_base();
    void set_allocated_base(::milvus::proto::common::MsgBase* base);
  
    // @@protoc_insertion_point(class_scope:milvus.proto.common.DMLMsgHeader)
   private:
    class _Internal;
  
    ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shardname_;
    ::milvus::proto::common::MsgBase* base_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2eproto;
  };
  // ===================================================================
  
  
  // ===================================================================
  
  #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing"
  #endif  // __GNUC__
  // Status
  
  // .milvus.proto.common.ErrorCode error_code = 1;
  inline void Status::clear_error_code() {
    error_code_ = 0;
  }
  inline ::milvus::proto::common::ErrorCode Status::error_code() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.Status.error_code)
    return static_cast< ::milvus::proto::common::ErrorCode >(error_code_);
  }
  inline void Status::set_error_code(::milvus::proto::common::ErrorCode value) {
    
    error_code_ = value;
    // @@protoc_insertion_point(field_set:milvus.proto.common.Status.error_code)
  }
  
  // string reason = 2;
  inline void Status::clear_reason() {
    reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& Status::reason() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.Status.reason)
    return reason_.GetNoArena();
  }
  inline void Status::set_reason(const std::string& value) {
    
    reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.proto.common.Status.reason)
  }
  inline void Status::set_reason(std::string&& value) {
    
    reason_.SetNoArena(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.Status.reason)
  }
  inline void Status::set_reason(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:milvus.proto.common.Status.reason)
  }
  inline void Status::set_reason(const char* value, size_t size) {
    
    reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.Status.reason)
  }
  inline std::string* Status::mutable_reason() {
    
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.Status.reason)
    return reason_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* Status::release_reason() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.Status.reason)
    
    return reason_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void Status::set_allocated_reason(std::string* reason) {
    if (reason != nullptr) {
      
    } else {
      
    }
    reason_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason);
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Status.reason)
  }
  
  // -------------------------------------------------------------------
  
  // KeyValuePair
  
  // string key = 1;
  inline void KeyValuePair::clear_key() {
    key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& KeyValuePair::key() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.KeyValuePair.key)
    return key_.GetNoArena();
  }
  inline void KeyValuePair::set_key(const std::string& value) {
    
    key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.proto.common.KeyValuePair.key)
  }
  inline void KeyValuePair::set_key(std::string&& value) {
    
    key_.SetNoArena(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.KeyValuePair.key)
  }
  inline void KeyValuePair::set_key(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:milvus.proto.common.KeyValuePair.key)
  }
  inline void KeyValuePair::set_key(const char* value, size_t size) {
    
    key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.KeyValuePair.key)
  }
  inline std::string* KeyValuePair::mutable_key() {
    
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyValuePair.key)
    return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* KeyValuePair::release_key() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.KeyValuePair.key)
    
    return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void KeyValuePair::set_allocated_key(std::string* key) {
    if (key != nullptr) {
      
    } else {
      
    }
    key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyValuePair.key)
  }
  
  // string value = 2;
  inline void KeyValuePair::clear_value() {
    value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& KeyValuePair::value() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.KeyValuePair.value)
    return value_.GetNoArena();
  }
  inline void KeyValuePair::set_value(const std::string& value) {
    
    value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.proto.common.KeyValuePair.value)
  }
  inline void KeyValuePair::set_value(std::string&& value) {
    
    value_.SetNoArena(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.KeyValuePair.value)
  }
  inline void KeyValuePair::set_value(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:milvus.proto.common.KeyValuePair.value)
  }
  inline void KeyValuePair::set_value(const char* value, size_t size) {
    
    value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.KeyValuePair.value)
  }
  inline std::string* KeyValuePair::mutable_value() {
    
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyValuePair.value)
    return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* KeyValuePair::release_value() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.KeyValuePair.value)
    
    return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void KeyValuePair::set_allocated_value(std::string* value) {
    if (value != nullptr) {
      
    } else {
      
    }
    value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyValuePair.value)
  }
  
  // -------------------------------------------------------------------
  
  // KeyDataPair
  
  // string key = 1;
  inline void KeyDataPair::clear_key() {
    key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& KeyDataPair::key() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.KeyDataPair.key)
    return key_.GetNoArena();
  }
  inline void KeyDataPair::set_key(const std::string& value) {
    
    key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.proto.common.KeyDataPair.key)
  }
  inline void KeyDataPair::set_key(std::string&& value) {
    
    key_.SetNoArena(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.KeyDataPair.key)
  }
  inline void KeyDataPair::set_key(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:milvus.proto.common.KeyDataPair.key)
  }
  inline void KeyDataPair::set_key(const char* value, size_t size) {
    
    key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.KeyDataPair.key)
  }
  inline std::string* KeyDataPair::mutable_key() {
    
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyDataPair.key)
    return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* KeyDataPair::release_key() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.KeyDataPair.key)
    
    return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void KeyDataPair::set_allocated_key(std::string* key) {
    if (key != nullptr) {
      
    } else {
      
    }
    key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyDataPair.key)
  }
  
  // bytes data = 2;
  inline void KeyDataPair::clear_data() {
    data_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& KeyDataPair::data() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.KeyDataPair.data)
    return data_.GetNoArena();
  }
  inline void KeyDataPair::set_data(const std::string& value) {
    
    data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.proto.common.KeyDataPair.data)
  }
  inline void KeyDataPair::set_data(std::string&& value) {
    
    data_.SetNoArena(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.KeyDataPair.data)
  }
  inline void KeyDataPair::set_data(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:milvus.proto.common.KeyDataPair.data)
  }
  inline void KeyDataPair::set_data(const void* value, size_t size) {
    
    data_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.KeyDataPair.data)
  }
  inline std::string* KeyDataPair::mutable_data() {
    
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyDataPair.data)
    return data_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* KeyDataPair::release_data() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.KeyDataPair.data)
    
    return data_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void KeyDataPair::set_allocated_data(std::string* data) {
    if (data != nullptr) {
      
    } else {
      
    }
    data_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data);
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyDataPair.data)
  }
  
  // -------------------------------------------------------------------
  
  // Blob
  
  // bytes value = 1;
  inline void Blob::clear_value() {
    value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& Blob::value() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.Blob.value)
    return value_.GetNoArena();
  }
  inline void Blob::set_value(const std::string& value) {
    
    value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.proto.common.Blob.value)
  }
  inline void Blob::set_value(std::string&& value) {
    
    value_.SetNoArena(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.Blob.value)
  }
  inline void Blob::set_value(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:milvus.proto.common.Blob.value)
  }
  inline void Blob::set_value(const void* value, size_t size) {
    
    value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.Blob.value)
  }
  inline std::string* Blob::mutable_value() {
    
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.Blob.value)
    return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* Blob::release_value() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.Blob.value)
    
    return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void Blob::set_allocated_value(std::string* value) {
    if (value != nullptr) {
      
    } else {
      
    }
    value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Blob.value)
  }
  
  // -------------------------------------------------------------------
  
  // Address
  
  // string ip = 1;
  inline void Address::clear_ip() {
    ip_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& Address::ip() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.Address.ip)
    return ip_.GetNoArena();
  }
  inline void Address::set_ip(const std::string& value) {
    
    ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.proto.common.Address.ip)
  }
  inline void Address::set_ip(std::string&& value) {
    
    ip_.SetNoArena(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.Address.ip)
  }
  inline void Address::set_ip(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:milvus.proto.common.Address.ip)
  }
  inline void Address::set_ip(const char* value, size_t size) {
    
    ip_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.Address.ip)
  }
  inline std::string* Address::mutable_ip() {
    
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.Address.ip)
    return ip_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* Address::release_ip() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.Address.ip)
    
    return ip_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void Address::set_allocated_ip(std::string* ip) {
    if (ip != nullptr) {
      
    } else {
      
    }
    ip_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip);
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Address.ip)
  }
  
  // int64 port = 2;
  inline void Address::clear_port() {
    port_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 Address::port() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.Address.port)
    return port_;
  }
  inline void Address::set_port(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    port_ = value;
    // @@protoc_insertion_point(field_set:milvus.proto.common.Address.port)
  }
  
  // -------------------------------------------------------------------
  
  // MsgBase
  
  // .milvus.proto.common.MsgType msg_type = 1;
  inline void MsgBase::clear_msg_type() {
    msg_type_ = 0;
  }
  inline ::milvus::proto::common::MsgType MsgBase::msg_type() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.msg_type)
    return static_cast< ::milvus::proto::common::MsgType >(msg_type_);
  }
  inline void MsgBase::set_msg_type(::milvus::proto::common::MsgType value) {
    
    msg_type_ = value;
    // @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.msg_type)
  }
  
  // int64 msgID = 2;
  inline void MsgBase::clear_msgid() {
    msgid_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 MsgBase::msgid() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.msgID)
    return msgid_;
  }
  inline void MsgBase::set_msgid(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    msgid_ = value;
    // @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.msgID)
  }
  
  // uint64 timestamp = 3;
  inline void MsgBase::clear_timestamp() {
    timestamp_ = PROTOBUF_ULONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 MsgBase::timestamp() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.timestamp)
    return timestamp_;
  }
  inline void MsgBase::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    
    timestamp_ = value;
    // @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.timestamp)
  }
  
  // int64 sourceID = 4;
  inline void MsgBase::clear_sourceid() {
    sourceid_ = PROTOBUF_LONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 MsgBase::sourceid() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.sourceID)
    return sourceid_;
  }
  inline void MsgBase::set_sourceid(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    sourceid_ = value;
    // @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.sourceID)
  }
  
  // -------------------------------------------------------------------
  
  // MsgHeader
  
  // .milvus.proto.common.MsgBase base = 1;
  inline bool MsgHeader::has_base() const {
    return this != internal_default_instance() && base_ != nullptr;
  }
  inline void MsgHeader::clear_base() {
    if (GetArenaNoVirtual() == nullptr && base_ != nullptr) {
      delete base_;
    }
    base_ = nullptr;
  }
  inline const ::milvus::proto::common::MsgBase& MsgHeader::base() const {
    const ::milvus::proto::common::MsgBase* p = base_;
    // @@protoc_insertion_point(field_get:milvus.proto.common.MsgHeader.base)
    return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::MsgBase*>(
        &::milvus::proto::common::_MsgBase_default_instance_);
  }
  inline ::milvus::proto::common::MsgBase* MsgHeader::release_base() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.MsgHeader.base)
    
    ::milvus::proto::common::MsgBase* temp = base_;
    base_ = nullptr;
    return temp;
  }
  inline ::milvus::proto::common::MsgBase* MsgHeader::mutable_base() {
    
    if (base_ == nullptr) {
      auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaNoVirtual());
      base_ = p;
    }
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.MsgHeader.base)
    return base_;
  }
  inline void MsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete base_;
    }
    if (base) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, base, submessage_arena);
      }
      
    } else {
      
    }
    base_ = base;
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.MsgHeader.base)
  }
  
  // -------------------------------------------------------------------
  
  // DMLMsgHeader
  
  // .milvus.proto.common.MsgBase base = 1;
  inline bool DMLMsgHeader::has_base() const {
    return this != internal_default_instance() && base_ != nullptr;
  }
  inline void DMLMsgHeader::clear_base() {
    if (GetArenaNoVirtual() == nullptr && base_ != nullptr) {
      delete base_;
    }
    base_ = nullptr;
  }
  inline const ::milvus::proto::common::MsgBase& DMLMsgHeader::base() const {
    const ::milvus::proto::common::MsgBase* p = base_;
    // @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.base)
    return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::MsgBase*>(
        &::milvus::proto::common::_MsgBase_default_instance_);
  }
  inline ::milvus::proto::common::MsgBase* DMLMsgHeader::release_base() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.base)
    
    ::milvus::proto::common::MsgBase* temp = base_;
    base_ = nullptr;
    return temp;
  }
  inline ::milvus::proto::common::MsgBase* DMLMsgHeader::mutable_base() {
    
    if (base_ == nullptr) {
      auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaNoVirtual());
      base_ = p;
    }
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.base)
    return base_;
  }
  inline void DMLMsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
    if (message_arena == nullptr) {
      delete base_;
    }
    if (base) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
      if (message_arena != submessage_arena) {
        base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, base, submessage_arena);
      }
      
    } else {
      
    }
    base_ = base;
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.DMLMsgHeader.base)
  }
  
  // string shardName = 2;
  inline void DMLMsgHeader::clear_shardname() {
    shardname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline const std::string& DMLMsgHeader::shardname() const {
    // @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.shardName)
    return shardname_.GetNoArena();
  }
  inline void DMLMsgHeader::set_shardname(const std::string& value) {
    
    shardname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
    // @@protoc_insertion_point(field_set:milvus.proto.common.DMLMsgHeader.shardName)
  }
  inline void DMLMsgHeader::set_shardname(std::string&& value) {
    
    shardname_.SetNoArena(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
    // @@protoc_insertion_point(field_set_rvalue:milvus.proto.common.DMLMsgHeader.shardName)
  }
  inline void DMLMsgHeader::set_shardname(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    shardname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
    // @@protoc_insertion_point(field_set_char:milvus.proto.common.DMLMsgHeader.shardName)
  }
  inline void DMLMsgHeader::set_shardname(const char* value, size_t size) {
    
    shardname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        ::std::string(reinterpret_cast<const char*>(value), size));
    // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.DMLMsgHeader.shardName)
  }
  inline std::string* DMLMsgHeader::mutable_shardname() {
    
    // @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.shardName)
    return shardname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline std::string* DMLMsgHeader::release_shardname() {
    // @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.shardName)
    
    return shardname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  inline void DMLMsgHeader::set_allocated_shardname(std::string* shardname) {
    if (shardname != nullptr) {
      
    } else {
      
    }
    shardname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shardname);
    // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.DMLMsgHeader.shardName)
  }
  
  #ifdef __GNUC__
    #pragma GCC diagnostic pop
  #endif  // __GNUC__
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace common
  }  // namespace proto
  }  // namespace milvus
  
  PROTOBUF_NAMESPACE_OPEN
  
  template <> struct is_proto_enum< ::milvus::proto::common::ErrorCode> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ErrorCode>() {
    return ::milvus::proto::common::ErrorCode_descriptor();
  }
  template <> struct is_proto_enum< ::milvus::proto::common::IndexState> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::IndexState>() {
    return ::milvus::proto::common::IndexState_descriptor();
  }
  template <> struct is_proto_enum< ::milvus::proto::common::SegmentState> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::SegmentState>() {
    return ::milvus::proto::common::SegmentState_descriptor();
  }
  template <> struct is_proto_enum< ::milvus::proto::common::MsgType> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::MsgType>() {
    return ::milvus::proto::common::MsgType_descriptor();
  }
  template <> struct is_proto_enum< ::milvus::proto::common::DslType> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::DslType>() {
    return ::milvus::proto::common::DslType_descriptor();
  }
  template <> struct is_proto_enum< ::milvus::proto::common::CompactionState> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::CompactionState>() {
    return ::milvus::proto::common::CompactionState_descriptor();
  }
  template <> struct is_proto_enum< ::milvus::proto::common::ConsistencyLevel> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ConsistencyLevel>() {
    return ::milvus::proto::common::ConsistencyLevel_descriptor();
  }
  template <> struct is_proto_enum< ::milvus::proto::common::ImportState> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ImportState>() {
    return ::milvus::proto::common::ImportState_descriptor();
  }
  
  PROTOBUF_NAMESPACE_CLOSE
  
  // @@protoc_insertion_point(global_scope)
  
  #include <google/protobuf/port_undef.inc>
  #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_common_2eproto
  