// 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 < 3021000
#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 3021004 < 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_util.h>
#include <google/protobuf/metadata_lite.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>
#include <google/protobuf/descriptor.pb.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 uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto;
namespace milvus {
namespace proto {
namespace common {
class Address;
struct AddressDefaultTypeInternal;
extern AddressDefaultTypeInternal _Address_default_instance_;
class Blob;
struct BlobDefaultTypeInternal;
extern BlobDefaultTypeInternal _Blob_default_instance_;
class DMLMsgHeader;
struct DMLMsgHeaderDefaultTypeInternal;
extern DMLMsgHeaderDefaultTypeInternal _DMLMsgHeader_default_instance_;
class KeyDataPair;
struct KeyDataPairDefaultTypeInternal;
extern KeyDataPairDefaultTypeInternal _KeyDataPair_default_instance_;
class KeyValuePair;
struct KeyValuePairDefaultTypeInternal;
extern KeyValuePairDefaultTypeInternal _KeyValuePair_default_instance_;
class MsgBase;
struct MsgBaseDefaultTypeInternal;
extern MsgBaseDefaultTypeInternal _MsgBase_default_instance_;
class MsgHeader;
struct MsgHeaderDefaultTypeInternal;
extern MsgHeaderDefaultTypeInternal _MsgHeader_default_instance_;
class PlaceholderGroup;
struct PlaceholderGroupDefaultTypeInternal;
extern PlaceholderGroupDefaultTypeInternal _PlaceholderGroup_default_instance_;
class PlaceholderValue;
struct PlaceholderValueDefaultTypeInternal;
extern PlaceholderValueDefaultTypeInternal _PlaceholderValue_default_instance_;
class PrivilegeExt;
struct PrivilegeExtDefaultTypeInternal;
extern PrivilegeExtDefaultTypeInternal _PrivilegeExt_default_instance_;
class SegmentStats;
struct SegmentStatsDefaultTypeInternal;
extern SegmentStatsDefaultTypeInternal _SegmentStats_default_instance_;
class Status;
struct 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::PlaceholderGroup* Arena::CreateMaybeMessage<::milvus::proto::common::PlaceholderGroup>(Arena*);
template<> ::milvus::proto::common::PlaceholderValue* Arena::CreateMaybeMessage<::milvus::proto::common::PlaceholderValue>(Arena*);
template<> ::milvus::proto::common::PrivilegeExt* Arena::CreateMaybeMessage<::milvus::proto::common::PrivilegeExt>(Arena*);
template<> ::milvus::proto::common::SegmentStats* Arena::CreateMaybeMessage<::milvus::proto::common::SegmentStats>(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,
  GetUserFailure = 34,
  CreateRoleFailure = 35,
  DropRoleFailure = 36,
  OperateUserRoleFailure = 37,
  SelectRoleFailure = 38,
  SelectUserFailure = 39,
  SelectResourceFailure = 40,
  OperatePrivilegeFailure = 41,
  SelectGrantFailure = 42,
  RefreshPolicyInfoCacheFailure = 43,
  ListPolicyFailure = 44,
  NotShardLeader = 45,
  NoReplicaAvailable = 46,
  SegmentNotFound = 47,
  ForceDeny = 48,
  RateLimit = 49,
  NodeIDNotMatch = 50,
  UpsertAutoIDTrue = 51,
  InsufficientMemoryToLoad = 52,
  MemoryQuotaExhausted = 53,
  DiskQuotaExhausted = 54,
  TimeTickLongDelay = 55,
  NotReadyServe = 56,
  NotReadyCoordActivating = 57,
  DataCoordNA = 100,
  DDRequestRace = 1000,
  ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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,
  Retry = 5,
  IndexState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  IndexState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool IndexState_IsValid(int value);
constexpr IndexState IndexState_MIN = IndexStateNone;
constexpr IndexState IndexState_MAX = Retry;
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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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<int32_t>::min(),
  SegmentState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SegmentState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SegmentState>(
    SegmentState_descriptor(), name, value);
}
enum PlaceholderType : int {
  None = 0,
  BinaryVector = 100,
  FloatVector = 101,
  PlaceholderType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  PlaceholderType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool PlaceholderType_IsValid(int value);
constexpr PlaceholderType PlaceholderType_MIN = None;
constexpr PlaceholderType PlaceholderType_MAX = FloatVector;
constexpr int PlaceholderType_ARRAYSIZE = PlaceholderType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlaceholderType_descriptor();
template<typename T>
inline const std::string& PlaceholderType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PlaceholderType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PlaceholderType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PlaceholderType_descriptor(), enum_t_value);
}
inline bool PlaceholderType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlaceholderType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlaceholderType>(
    PlaceholderType_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,
  AlterCollection = 111,
  RenameCollection = 112,
  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,
  ResendSegmentStats = 403,
  Upsert = 404,
  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,
  UnsubDmChannel = 516,
  GetDistribution = 517,
  SyncDistribution = 518,
  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,
  CreateRole = 1600,
  DropRole = 1601,
  OperateUserRole = 1602,
  SelectRole = 1603,
  SelectUser = 1604,
  SelectResource = 1605,
  OperatePrivilege = 1606,
  SelectGrant = 1607,
  RefreshPolicyInfoCache = 1608,
  ListPolicy = 1609,
  CreateResourceGroup = 1700,
  DropResourceGroup = 1701,
  ListResourceGroups = 1702,
  DescribeResourceGroup = 1703,
  TransferNode = 1704,
  TransferReplica = 1705,
  MsgType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  MsgType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool MsgType_IsValid(int value);
constexpr MsgType MsgType_MIN = Undefined;
constexpr MsgType MsgType_MAX = TransferReplica;
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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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<int32_t>::min(),
  DslType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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<int32_t>::min(),
  CompactionState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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<int32_t>::min(),
  ConsistencyLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConsistencyLevel* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConsistencyLevel>(
    ConsistencyLevel_descriptor(), name, value);
}
enum ImportState : int {
  ImportPending = 0,
  ImportFailed = 1,
  ImportStarted = 2,
  ImportPersisted = 5,
  ImportFlushed = 8,
  ImportCompleted = 6,
  ImportFailedAndCleaned = 7,
  ImportState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ImportState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ImportState_IsValid(int value);
constexpr ImportState ImportState_MIN = ImportPending;
constexpr ImportState ImportState_MAX = ImportFlushed;
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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ImportState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ImportState>(
    ImportState_descriptor(), name, value);
}
enum ObjectType : int {
  Collection = 0,
  Global = 1,
  User = 2,
  ObjectType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ObjectType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ObjectType_IsValid(int value);
constexpr ObjectType ObjectType_MIN = Collection;
constexpr ObjectType ObjectType_MAX = User;
constexpr int ObjectType_ARRAYSIZE = ObjectType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ObjectType_descriptor();
template<typename T>
inline const std::string& ObjectType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ObjectType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ObjectType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ObjectType_descriptor(), enum_t_value);
}
inline bool ObjectType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ObjectType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ObjectType>(
    ObjectType_descriptor(), name, value);
}
enum ObjectPrivilege : int {
  PrivilegeAll = 0,
  PrivilegeCreateCollection = 1,
  PrivilegeDropCollection = 2,
  PrivilegeDescribeCollection = 3,
  PrivilegeShowCollections = 4,
  PrivilegeLoad = 5,
  PrivilegeRelease = 6,
  PrivilegeCompaction = 7,
  PrivilegeInsert = 8,
  PrivilegeDelete = 9,
  PrivilegeGetStatistics = 10,
  PrivilegeCreateIndex = 11,
  PrivilegeIndexDetail = 12,
  PrivilegeDropIndex = 13,
  PrivilegeSearch = 14,
  PrivilegeFlush = 15,
  PrivilegeQuery = 16,
  PrivilegeLoadBalance = 17,
  PrivilegeImport = 18,
  PrivilegeCreateOwnership = 19,
  PrivilegeUpdateUser = 20,
  PrivilegeDropOwnership = 21,
  PrivilegeSelectOwnership = 22,
  PrivilegeManageOwnership = 23,
  PrivilegeSelectUser = 24,
  PrivilegeUpsert = 25,
  PrivilegeCreateResourceGroup = 26,
  PrivilegeDropResourceGroup = 27,
  PrivilegeDescribeResourceGroup = 28,
  PrivilegeListResourceGroups = 29,
  PrivilegeTransferNode = 30,
  PrivilegeTransferReplica = 31,
  PrivilegeGetLoadingProgress = 32,
  PrivilegeGetLoadState = 33,
  ObjectPrivilege_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  ObjectPrivilege_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool ObjectPrivilege_IsValid(int value);
constexpr ObjectPrivilege ObjectPrivilege_MIN = PrivilegeAll;
constexpr ObjectPrivilege ObjectPrivilege_MAX = PrivilegeGetLoadState;
constexpr int ObjectPrivilege_ARRAYSIZE = ObjectPrivilege_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ObjectPrivilege_descriptor();
template<typename T>
inline const std::string& ObjectPrivilege_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ObjectPrivilege>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ObjectPrivilege_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ObjectPrivilege_descriptor(), enum_t_value);
}
inline bool ObjectPrivilege_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ObjectPrivilege* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ObjectPrivilege>(
    ObjectPrivilege_descriptor(), name, value);
}
enum StateCode : int {
  Initializing = 0,
  Healthy = 1,
  Abnormal = 2,
  StandBy = 3,
  Stopping = 4,
  StateCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  StateCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool StateCode_IsValid(int value);
constexpr StateCode StateCode_MIN = Initializing;
constexpr StateCode StateCode_MAX = Stopping;
constexpr int StateCode_ARRAYSIZE = StateCode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StateCode_descriptor();
template<typename T>
inline const std::string& StateCode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, StateCode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function StateCode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    StateCode_descriptor(), enum_t_value);
}
inline bool StateCode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StateCode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StateCode>(
    StateCode_descriptor(), name, value);
}
enum LoadState : int {
  LoadStateNotExist = 0,
  LoadStateNotLoad = 1,
  LoadStateLoading = 2,
  LoadStateLoaded = 3,
  LoadState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  LoadState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool LoadState_IsValid(int value);
constexpr LoadState LoadState_MIN = LoadStateNotExist;
constexpr LoadState LoadState_MAX = LoadStateLoaded;
constexpr int LoadState_ARRAYSIZE = LoadState_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LoadState_descriptor();
template<typename T>
inline const std::string& LoadState_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LoadState>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LoadState_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LoadState_descriptor(), enum_t_value);
}
inline bool LoadState_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoadState* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LoadState>(
    LoadState_descriptor(), name, value);
}
// ===================================================================

class Status final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Status) */ {
 public:
  inline Status() : Status(nullptr) {}
  ~Status() override;
  explicit PROTOBUF_CONSTEXPR Status(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Status& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Status* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Status>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Status& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Status& from) {
    Status::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Status* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.Status";
  }
  protected:
  explicit Status(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kReasonFieldNumber = 2,
    kErrorCodeFieldNumber = 1,
    kCodeFieldNumber = 3,
  };
  // string reason = 2;
  void clear_reason();
  const std::string& reason() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_reason(ArgT0&& arg0, ArgT... args);
  std::string* mutable_reason();
  PROTOBUF_NODISCARD std::string* release_reason();
  void set_allocated_reason(std::string* reason);
  private:
  const std::string& _internal_reason() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_reason(const std::string& value);
  std::string* _internal_mutable_reason();
  public:

  // .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);
  private:
  ::milvus::proto::common::ErrorCode _internal_error_code() const;
  void _internal_set_error_code(::milvus::proto::common::ErrorCode value);
  public:

  // int32 code = 3;
  void clear_code();
  int32_t code() const;
  void set_code(int32_t value);
  private:
  int32_t _internal_code() const;
  void _internal_set_code(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.common.Status)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_;
    int error_code_;
    int32_t code_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class KeyValuePair final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.KeyValuePair) */ {
 public:
  inline KeyValuePair() : KeyValuePair(nullptr) {}
  ~KeyValuePair() override;
  explicit PROTOBUF_CONSTEXPR KeyValuePair(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const KeyValuePair& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(KeyValuePair* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  KeyValuePair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<KeyValuePair>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const KeyValuePair& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const KeyValuePair& from) {
    KeyValuePair::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(KeyValuePair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.KeyValuePair";
  }
  protected:
  explicit KeyValuePair(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kKeyFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // string value = 2;
  void clear_value();
  const std::string& value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);
  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
  std::string* _internal_mutable_value();
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.common.KeyValuePair)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class KeyDataPair final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.KeyDataPair) */ {
 public:
  inline KeyDataPair() : KeyDataPair(nullptr) {}
  ~KeyDataPair() override;
  explicit PROTOBUF_CONSTEXPR KeyDataPair(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const KeyDataPair& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(KeyDataPair* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  KeyDataPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<KeyDataPair>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const KeyDataPair& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const KeyDataPair& from) {
    KeyDataPair::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(KeyDataPair* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.KeyDataPair";
  }
  protected:
  explicit KeyDataPair(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kKeyFieldNumber = 1,
    kDataFieldNumber = 2,
  };
  // string key = 1;
  void clear_key();
  const std::string& key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key();
  PROTOBUF_NODISCARD std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // bytes data = 2;
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.common.KeyDataPair)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class Blob final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Blob) */ {
 public:
  inline Blob() : Blob(nullptr) {}
  ~Blob() override;
  explicit PROTOBUF_CONSTEXPR Blob(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Blob& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Blob* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Blob* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Blob>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Blob& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Blob& from) {
    Blob::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Blob* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.Blob";
  }
  protected:
  explicit Blob(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // bytes value = 1;
  void clear_value();
  const std::string& value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);
  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
  std::string* _internal_mutable_value();
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.common.Blob)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class PlaceholderValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.PlaceholderValue) */ {
 public:
  inline PlaceholderValue() : PlaceholderValue(nullptr) {}
  ~PlaceholderValue() override;
  explicit PROTOBUF_CONSTEXPR PlaceholderValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PlaceholderValue(const PlaceholderValue& from);
  PlaceholderValue(PlaceholderValue&& from) noexcept
    : PlaceholderValue() {
    *this = ::std::move(from);
  }

  inline PlaceholderValue& operator=(const PlaceholderValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline PlaceholderValue& operator=(PlaceholderValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PlaceholderValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const PlaceholderValue* internal_default_instance() {
    return reinterpret_cast<const PlaceholderValue*>(
               &_PlaceholderValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(PlaceholderValue& a, PlaceholderValue& b) {
    a.Swap(&b);
  }
  inline void Swap(PlaceholderValue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PlaceholderValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PlaceholderValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PlaceholderValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PlaceholderValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PlaceholderValue& from) {
    PlaceholderValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PlaceholderValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.PlaceholderValue";
  }
  protected:
  explicit PlaceholderValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValuesFieldNumber = 3,
    kTagFieldNumber = 1,
    kTypeFieldNumber = 2,
  };
  // repeated bytes values = 3;
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  const std::string& values(int index) const;
  std::string* mutable_values(int index);
  void set_values(int index, const std::string& value);
  void set_values(int index, std::string&& value);
  void set_values(int index, const char* value);
  void set_values(int index, const void* value, size_t size);
  std::string* add_values();
  void add_values(const std::string& value);
  void add_values(std::string&& value);
  void add_values(const char* value);
  void add_values(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_values();
  private:
  const std::string& _internal_values(int index) const;
  std::string* _internal_add_values();
  public:

  // string tag = 1;
  void clear_tag();
  const std::string& tag() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tag(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tag();
  PROTOBUF_NODISCARD std::string* release_tag();
  void set_allocated_tag(std::string* tag);
  private:
  const std::string& _internal_tag() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tag(const std::string& value);
  std::string* _internal_mutable_tag();
  public:

  // .milvus.proto.common.PlaceholderType type = 2;
  void clear_type();
  ::milvus::proto::common::PlaceholderType type() const;
  void set_type(::milvus::proto::common::PlaceholderType value);
  private:
  ::milvus::proto::common::PlaceholderType _internal_type() const;
  void _internal_set_type(::milvus::proto::common::PlaceholderType value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.common.PlaceholderValue)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> values_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_;
    int type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class PlaceholderGroup final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.PlaceholderGroup) */ {
 public:
  inline PlaceholderGroup() : PlaceholderGroup(nullptr) {}
  ~PlaceholderGroup() override;
  explicit PROTOBUF_CONSTEXPR PlaceholderGroup(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PlaceholderGroup(const PlaceholderGroup& from);
  PlaceholderGroup(PlaceholderGroup&& from) noexcept
    : PlaceholderGroup() {
    *this = ::std::move(from);
  }

  inline PlaceholderGroup& operator=(const PlaceholderGroup& from) {
    CopyFrom(from);
    return *this;
  }
  inline PlaceholderGroup& operator=(PlaceholderGroup&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PlaceholderGroup& default_instance() {
    return *internal_default_instance();
  }
  static inline const PlaceholderGroup* internal_default_instance() {
    return reinterpret_cast<const PlaceholderGroup*>(
               &_PlaceholderGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(PlaceholderGroup& a, PlaceholderGroup& b) {
    a.Swap(&b);
  }
  inline void Swap(PlaceholderGroup* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PlaceholderGroup* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PlaceholderGroup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PlaceholderGroup>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PlaceholderGroup& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PlaceholderGroup& from) {
    PlaceholderGroup::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PlaceholderGroup* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.PlaceholderGroup";
  }
  protected:
  explicit PlaceholderGroup(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kPlaceholdersFieldNumber = 1,
  };
  // repeated .milvus.proto.common.PlaceholderValue placeholders = 1;
  int placeholders_size() const;
  private:
  int _internal_placeholders_size() const;
  public:
  void clear_placeholders();
  ::milvus::proto::common::PlaceholderValue* mutable_placeholders(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue >*
      mutable_placeholders();
  private:
  const ::milvus::proto::common::PlaceholderValue& _internal_placeholders(int index) const;
  ::milvus::proto::common::PlaceholderValue* _internal_add_placeholders();
  public:
  const ::milvus::proto::common::PlaceholderValue& placeholders(int index) const;
  ::milvus::proto::common::PlaceholderValue* add_placeholders();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue >&
      placeholders() const;

  // @@protoc_insertion_point(class_scope:milvus.proto.common.PlaceholderGroup)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue > placeholders_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class Address final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.Address) */ {
 public:
  inline Address() : Address(nullptr) {}
  ~Address() override;
  explicit PROTOBUF_CONSTEXPR Address(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Address& default_instance() {
    return *internal_default_instance();
  }
  static inline const Address* internal_default_instance() {
    return reinterpret_cast<const Address*>(
               &_Address_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(Address& a, Address& b) {
    a.Swap(&b);
  }
  inline void Swap(Address* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Address* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Address* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Address>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Address& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Address& from) {
    Address::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Address* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.Address";
  }
  protected:
  explicit Address(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIpFieldNumber = 1,
    kPortFieldNumber = 2,
  };
  // string ip = 1;
  void clear_ip();
  const std::string& ip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ip();
  PROTOBUF_NODISCARD std::string* release_ip();
  void set_allocated_ip(std::string* ip);
  private:
  const std::string& _internal_ip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip(const std::string& value);
  std::string* _internal_mutable_ip();
  public:

  // int64 port = 2;
  void clear_port();
  int64_t port() const;
  void set_port(int64_t value);
  private:
  int64_t _internal_port() const;
  void _internal_set_port(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.common.Address)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_;
    int64_t port_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class MsgBase final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.MsgBase) */ {
 public:
  inline MsgBase() : MsgBase(nullptr) {}
  ~MsgBase() override;
  explicit PROTOBUF_CONSTEXPR MsgBase(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MsgBase& default_instance() {
    return *internal_default_instance();
  }
  static inline const MsgBase* internal_default_instance() {
    return reinterpret_cast<const MsgBase*>(
               &_MsgBase_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(MsgBase& a, MsgBase& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgBase* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MsgBase* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MsgBase* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MsgBase>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MsgBase& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MsgBase& from) {
    MsgBase::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MsgBase* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.MsgBase";
  }
  protected:
  explicit MsgBase(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kMsgIDFieldNumber = 2,
    kTimestampFieldNumber = 3,
    kSourceIDFieldNumber = 4,
    kTargetIDFieldNumber = 5,
    kMsgTypeFieldNumber = 1,
  };
  // int64 msgID = 2;
  void clear_msgid();
  int64_t msgid() const;
  void set_msgid(int64_t value);
  private:
  int64_t _internal_msgid() const;
  void _internal_set_msgid(int64_t value);
  public:

  // uint64 timestamp = 3;
  void clear_timestamp();
  uint64_t timestamp() const;
  void set_timestamp(uint64_t value);
  private:
  uint64_t _internal_timestamp() const;
  void _internal_set_timestamp(uint64_t value);
  public:

  // int64 sourceID = 4;
  void clear_sourceid();
  int64_t sourceid() const;
  void set_sourceid(int64_t value);
  private:
  int64_t _internal_sourceid() const;
  void _internal_set_sourceid(int64_t value);
  public:

  // int64 targetID = 5;
  void clear_targetid();
  int64_t targetid() const;
  void set_targetid(int64_t value);
  private:
  int64_t _internal_targetid() const;
  void _internal_set_targetid(int64_t value);
  public:

  // .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);
  private:
  ::milvus::proto::common::MsgType _internal_msg_type() const;
  void _internal_set_msg_type(::milvus::proto::common::MsgType value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.common.MsgBase)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int64_t msgid_;
    uint64_t timestamp_;
    int64_t sourceid_;
    int64_t targetid_;
    int msg_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class MsgHeader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.MsgHeader) */ {
 public:
  inline MsgHeader() : MsgHeader(nullptr) {}
  ~MsgHeader() override;
  explicit PROTOBUF_CONSTEXPR MsgHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MsgHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const MsgHeader* internal_default_instance() {
    return reinterpret_cast<const MsgHeader*>(
               &_MsgHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(MsgHeader& a, MsgHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgHeader* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MsgHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MsgHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MsgHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MsgHeader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MsgHeader& from) {
    MsgHeader::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MsgHeader* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.MsgHeader";
  }
  protected:
  explicit MsgHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kBaseFieldNumber = 1,
  };
  // .milvus.proto.common.MsgBase base = 1;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  const ::milvus::proto::common::MsgBase& base() const;
  PROTOBUF_NODISCARD ::milvus::proto::common::MsgBase* release_base();
  ::milvus::proto::common::MsgBase* mutable_base();
  void set_allocated_base(::milvus::proto::common::MsgBase* base);
  private:
  const ::milvus::proto::common::MsgBase& _internal_base() const;
  ::milvus::proto::common::MsgBase* _internal_mutable_base();
  public:
  void unsafe_arena_set_allocated_base(
      ::milvus::proto::common::MsgBase* base);
  ::milvus::proto::common::MsgBase* unsafe_arena_release_base();

  // @@protoc_insertion_point(class_scope:milvus.proto.common.MsgHeader)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::milvus::proto::common::MsgBase* base_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class DMLMsgHeader final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.DMLMsgHeader) */ {
 public:
  inline DMLMsgHeader() : DMLMsgHeader(nullptr) {}
  ~DMLMsgHeader() override;
  explicit PROTOBUF_CONSTEXPR DMLMsgHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DMLMsgHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const DMLMsgHeader* internal_default_instance() {
    return reinterpret_cast<const DMLMsgHeader*>(
               &_DMLMsgHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(DMLMsgHeader& a, DMLMsgHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(DMLMsgHeader* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DMLMsgHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DMLMsgHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DMLMsgHeader>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DMLMsgHeader& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DMLMsgHeader& from) {
    DMLMsgHeader::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DMLMsgHeader* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.DMLMsgHeader";
  }
  protected:
  explicit DMLMsgHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kShardNameFieldNumber = 2,
    kBaseFieldNumber = 1,
  };
  // string shardName = 2;
  void clear_shardname();
  const std::string& shardname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_shardname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_shardname();
  PROTOBUF_NODISCARD std::string* release_shardname();
  void set_allocated_shardname(std::string* shardname);
  private:
  const std::string& _internal_shardname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_shardname(const std::string& value);
  std::string* _internal_mutable_shardname();
  public:

  // .milvus.proto.common.MsgBase base = 1;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  const ::milvus::proto::common::MsgBase& base() const;
  PROTOBUF_NODISCARD ::milvus::proto::common::MsgBase* release_base();
  ::milvus::proto::common::MsgBase* mutable_base();
  void set_allocated_base(::milvus::proto::common::MsgBase* base);
  private:
  const ::milvus::proto::common::MsgBase& _internal_base() const;
  ::milvus::proto::common::MsgBase* _internal_mutable_base();
  public:
  void unsafe_arena_set_allocated_base(
      ::milvus::proto::common::MsgBase* base);
  ::milvus::proto::common::MsgBase* unsafe_arena_release_base();

  // @@protoc_insertion_point(class_scope:milvus.proto.common.DMLMsgHeader)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shardname_;
    ::milvus::proto::common::MsgBase* base_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class PrivilegeExt final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.PrivilegeExt) */ {
 public:
  inline PrivilegeExt() : PrivilegeExt(nullptr) {}
  ~PrivilegeExt() override;
  explicit PROTOBUF_CONSTEXPR PrivilegeExt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PrivilegeExt(const PrivilegeExt& from);
  PrivilegeExt(PrivilegeExt&& from) noexcept
    : PrivilegeExt() {
    *this = ::std::move(from);
  }

  inline PrivilegeExt& operator=(const PrivilegeExt& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrivilegeExt& operator=(PrivilegeExt&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PrivilegeExt& default_instance() {
    return *internal_default_instance();
  }
  static inline const PrivilegeExt* internal_default_instance() {
    return reinterpret_cast<const PrivilegeExt*>(
               &_PrivilegeExt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(PrivilegeExt& a, PrivilegeExt& b) {
    a.Swap(&b);
  }
  inline void Swap(PrivilegeExt* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PrivilegeExt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PrivilegeExt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PrivilegeExt>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PrivilegeExt& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PrivilegeExt& from) {
    PrivilegeExt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PrivilegeExt* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.PrivilegeExt";
  }
  protected:
  explicit PrivilegeExt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kObjectTypeFieldNumber = 1,
    kObjectPrivilegeFieldNumber = 2,
    kObjectNameIndexFieldNumber = 3,
    kObjectNameIndexsFieldNumber = 4,
  };
  // .milvus.proto.common.ObjectType object_type = 1;
  void clear_object_type();
  ::milvus::proto::common::ObjectType object_type() const;
  void set_object_type(::milvus::proto::common::ObjectType value);
  private:
  ::milvus::proto::common::ObjectType _internal_object_type() const;
  void _internal_set_object_type(::milvus::proto::common::ObjectType value);
  public:

  // .milvus.proto.common.ObjectPrivilege object_privilege = 2;
  void clear_object_privilege();
  ::milvus::proto::common::ObjectPrivilege object_privilege() const;
  void set_object_privilege(::milvus::proto::common::ObjectPrivilege value);
  private:
  ::milvus::proto::common::ObjectPrivilege _internal_object_privilege() const;
  void _internal_set_object_privilege(::milvus::proto::common::ObjectPrivilege value);
  public:

  // int32 object_name_index = 3;
  void clear_object_name_index();
  int32_t object_name_index() const;
  void set_object_name_index(int32_t value);
  private:
  int32_t _internal_object_name_index() const;
  void _internal_set_object_name_index(int32_t value);
  public:

  // int32 object_name_indexs = 4;
  void clear_object_name_indexs();
  int32_t object_name_indexs() const;
  void set_object_name_indexs(int32_t value);
  private:
  int32_t _internal_object_name_indexs() const;
  void _internal_set_object_name_indexs(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.common.PrivilegeExt)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int object_type_;
    int object_privilege_;
    int32_t object_name_index_;
    int32_t object_name_indexs_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// -------------------------------------------------------------------

class SegmentStats final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.common.SegmentStats) */ {
 public:
  inline SegmentStats() : SegmentStats(nullptr) {}
  ~SegmentStats() override;
  explicit PROTOBUF_CONSTEXPR SegmentStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SegmentStats(const SegmentStats& from);
  SegmentStats(SegmentStats&& from) noexcept
    : SegmentStats() {
    *this = ::std::move(from);
  }

  inline SegmentStats& operator=(const SegmentStats& from) {
    CopyFrom(from);
    return *this;
  }
  inline SegmentStats& operator=(SegmentStats&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SegmentStats& default_instance() {
    return *internal_default_instance();
  }
  static inline const SegmentStats* internal_default_instance() {
    return reinterpret_cast<const SegmentStats*>(
               &_SegmentStats_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(SegmentStats& a, SegmentStats& b) {
    a.Swap(&b);
  }
  inline void Swap(SegmentStats* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SegmentStats* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SegmentStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SegmentStats>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SegmentStats& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SegmentStats& from) {
    SegmentStats::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SegmentStats* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.common.SegmentStats";
  }
  protected:
  explicit SegmentStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSegmentIDFieldNumber = 1,
    kNumRowsFieldNumber = 2,
  };
  // int64 SegmentID = 1;
  void clear_segmentid();
  int64_t segmentid() const;
  void set_segmentid(int64_t value);
  private:
  int64_t _internal_segmentid() const;
  void _internal_set_segmentid(int64_t value);
  public:

  // int64 NumRows = 2;
  void clear_numrows();
  int64_t numrows() const;
  void set_numrows(int64_t value);
  private:
  int64_t _internal_numrows() const;
  void _internal_set_numrows(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:milvus.proto.common.SegmentStats)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    int64_t segmentid_;
    int64_t numrows_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_common_2eproto;
};
// ===================================================================

static const int kPrivilegeExtObjFieldNumber = 1001;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::MessageOptions,
    ::PROTOBUF_NAMESPACE_ID::internal::MessageTypeTraits< ::milvus::proto::common::PrivilegeExt >, 11, false >
  privilege_ext_obj;

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

#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() {
  _impl_.error_code_ = 0;
}
inline ::milvus::proto::common::ErrorCode Status::_internal_error_code() const {
  return static_cast< ::milvus::proto::common::ErrorCode >(_impl_.error_code_);
}
inline ::milvus::proto::common::ErrorCode Status::error_code() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.Status.error_code)
  return _internal_error_code();
}
inline void Status::_internal_set_error_code(::milvus::proto::common::ErrorCode value) {
  
  _impl_.error_code_ = value;
}
inline void Status::set_error_code(::milvus::proto::common::ErrorCode value) {
  _internal_set_error_code(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.Status.error_code)
}

// string reason = 2;
inline void Status::clear_reason() {
  _impl_.reason_.ClearToEmpty();
}
inline const std::string& Status::reason() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.Status.reason)
  return _internal_reason();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Status::set_reason(ArgT0&& arg0, ArgT... args) {
 
 _impl_.reason_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.common.Status.reason)
}
inline std::string* Status::mutable_reason() {
  std::string* _s = _internal_mutable_reason();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.Status.reason)
  return _s;
}
inline const std::string& Status::_internal_reason() const {
  return _impl_.reason_.Get();
}
inline void Status::_internal_set_reason(const std::string& value) {
  
  _impl_.reason_.Set(value, GetArenaForAllocation());
}
inline std::string* Status::_internal_mutable_reason() {
  
  return _impl_.reason_.Mutable(GetArenaForAllocation());
}
inline std::string* Status::release_reason() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.Status.reason)
  return _impl_.reason_.Release();
}
inline void Status::set_allocated_reason(std::string* reason) {
  if (reason != nullptr) {
    
  } else {
    
  }
  _impl_.reason_.SetAllocated(reason, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.reason_.IsDefault()) {
    _impl_.reason_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Status.reason)
}

// int32 code = 3;
inline void Status::clear_code() {
  _impl_.code_ = 0;
}
inline int32_t Status::_internal_code() const {
  return _impl_.code_;
}
inline int32_t Status::code() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.Status.code)
  return _internal_code();
}
inline void Status::_internal_set_code(int32_t value) {
  
  _impl_.code_ = value;
}
inline void Status::set_code(int32_t value) {
  _internal_set_code(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.Status.code)
}

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

// KeyValuePair

// string key = 1;
inline void KeyValuePair::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& KeyValuePair::key() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.KeyValuePair.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyValuePair::set_key(ArgT0&& arg0, ArgT... args) {
 
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.common.KeyValuePair.key)
}
inline std::string* KeyValuePair::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyValuePair.key)
  return _s;
}
inline const std::string& KeyValuePair::_internal_key() const {
  return _impl_.key_.Get();
}
inline void KeyValuePair::_internal_set_key(const std::string& value) {
  
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyValuePair::_internal_mutable_key() {
  
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyValuePair::release_key() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.KeyValuePair.key)
  return _impl_.key_.Release();
}
inline void KeyValuePair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyValuePair.key)
}

// string value = 2;
inline void KeyValuePair::clear_value() {
  _impl_.value_.ClearToEmpty();
}
inline const std::string& KeyValuePair::value() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.KeyValuePair.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyValuePair::set_value(ArgT0&& arg0, ArgT... args) {
 
 _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.common.KeyValuePair.value)
}
inline std::string* KeyValuePair::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyValuePair.value)
  return _s;
}
inline const std::string& KeyValuePair::_internal_value() const {
  return _impl_.value_.Get();
}
inline void KeyValuePair::_internal_set_value(const std::string& value) {
  
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyValuePair::_internal_mutable_value() {
  
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyValuePair::release_value() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.KeyValuePair.value)
  return _impl_.value_.Release();
}
inline void KeyValuePair::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    
  } else {
    
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyValuePair.value)
}

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

// KeyDataPair

// string key = 1;
inline void KeyDataPair::clear_key() {
  _impl_.key_.ClearToEmpty();
}
inline const std::string& KeyDataPair::key() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.KeyDataPair.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyDataPair::set_key(ArgT0&& arg0, ArgT... args) {
 
 _impl_.key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.common.KeyDataPair.key)
}
inline std::string* KeyDataPair::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyDataPair.key)
  return _s;
}
inline const std::string& KeyDataPair::_internal_key() const {
  return _impl_.key_.Get();
}
inline void KeyDataPair::_internal_set_key(const std::string& value) {
  
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyDataPair::_internal_mutable_key() {
  
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyDataPair::release_key() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.KeyDataPair.key)
  return _impl_.key_.Release();
}
inline void KeyDataPair::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  _impl_.key_.SetAllocated(key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_.IsDefault()) {
    _impl_.key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyDataPair.key)
}

// bytes data = 2;
inline void KeyDataPair::clear_data() {
  _impl_.data_.ClearToEmpty();
}
inline const std::string& KeyDataPair::data() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.KeyDataPair.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyDataPair::set_data(ArgT0&& arg0, ArgT... args) {
 
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.common.KeyDataPair.data)
}
inline std::string* KeyDataPair::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.KeyDataPair.data)
  return _s;
}
inline const std::string& KeyDataPair::_internal_data() const {
  return _impl_.data_.Get();
}
inline void KeyDataPair::_internal_set_data(const std::string& value) {
  
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyDataPair::_internal_mutable_data() {
  
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyDataPair::release_data() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.KeyDataPair.data)
  return _impl_.data_.Release();
}
inline void KeyDataPair::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    
  } else {
    
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.KeyDataPair.data)
}

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

// Blob

// bytes value = 1;
inline void Blob::clear_value() {
  _impl_.value_.ClearToEmpty();
}
inline const std::string& Blob::value() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.Blob.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Blob::set_value(ArgT0&& arg0, ArgT... args) {
 
 _impl_.value_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.common.Blob.value)
}
inline std::string* Blob::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.Blob.value)
  return _s;
}
inline const std::string& Blob::_internal_value() const {
  return _impl_.value_.Get();
}
inline void Blob::_internal_set_value(const std::string& value) {
  
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* Blob::_internal_mutable_value() {
  
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* Blob::release_value() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.Blob.value)
  return _impl_.value_.Release();
}
inline void Blob::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    
  } else {
    
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Blob.value)
}

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

// PlaceholderValue

// string tag = 1;
inline void PlaceholderValue::clear_tag() {
  _impl_.tag_.ClearToEmpty();
}
inline const std::string& PlaceholderValue::tag() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderValue.tag)
  return _internal_tag();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PlaceholderValue::set_tag(ArgT0&& arg0, ArgT... args) {
 
 _impl_.tag_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.tag)
}
inline std::string* PlaceholderValue::mutable_tag() {
  std::string* _s = _internal_mutable_tag();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.PlaceholderValue.tag)
  return _s;
}
inline const std::string& PlaceholderValue::_internal_tag() const {
  return _impl_.tag_.Get();
}
inline void PlaceholderValue::_internal_set_tag(const std::string& value) {
  
  _impl_.tag_.Set(value, GetArenaForAllocation());
}
inline std::string* PlaceholderValue::_internal_mutable_tag() {
  
  return _impl_.tag_.Mutable(GetArenaForAllocation());
}
inline std::string* PlaceholderValue::release_tag() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.PlaceholderValue.tag)
  return _impl_.tag_.Release();
}
inline void PlaceholderValue::set_allocated_tag(std::string* tag) {
  if (tag != nullptr) {
    
  } else {
    
  }
  _impl_.tag_.SetAllocated(tag, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tag_.IsDefault()) {
    _impl_.tag_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.PlaceholderValue.tag)
}

// .milvus.proto.common.PlaceholderType type = 2;
inline void PlaceholderValue::clear_type() {
  _impl_.type_ = 0;
}
inline ::milvus::proto::common::PlaceholderType PlaceholderValue::_internal_type() const {
  return static_cast< ::milvus::proto::common::PlaceholderType >(_impl_.type_);
}
inline ::milvus::proto::common::PlaceholderType PlaceholderValue::type() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderValue.type)
  return _internal_type();
}
inline void PlaceholderValue::_internal_set_type(::milvus::proto::common::PlaceholderType value) {
  
  _impl_.type_ = value;
}
inline void PlaceholderValue::set_type(::milvus::proto::common::PlaceholderType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.type)
}

// repeated bytes values = 3;
inline int PlaceholderValue::_internal_values_size() const {
  return _impl_.values_.size();
}
inline int PlaceholderValue::values_size() const {
  return _internal_values_size();
}
inline void PlaceholderValue::clear_values() {
  _impl_.values_.Clear();
}
inline std::string* PlaceholderValue::add_values() {
  std::string* _s = _internal_add_values();
  // @@protoc_insertion_point(field_add_mutable:milvus.proto.common.PlaceholderValue.values)
  return _s;
}
inline const std::string& PlaceholderValue::_internal_values(int index) const {
  return _impl_.values_.Get(index);
}
inline const std::string& PlaceholderValue::values(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderValue.values)
  return _internal_values(index);
}
inline std::string* PlaceholderValue::mutable_values(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.PlaceholderValue.values)
  return _impl_.values_.Mutable(index);
}
inline void PlaceholderValue::set_values(int index, const std::string& value) {
  _impl_.values_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::set_values(int index, std::string&& value) {
  _impl_.values_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::set_values(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.values_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::set_values(int index, const void* value, size_t size) {
  _impl_.values_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.common.PlaceholderValue.values)
}
inline std::string* PlaceholderValue::_internal_add_values() {
  return _impl_.values_.Add();
}
inline void PlaceholderValue::add_values(const std::string& value) {
  _impl_.values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(std::string&& value) {
  _impl_.values_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.proto.common.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(const void* value, size_t size) {
  _impl_.values_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.proto.common.PlaceholderValue.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
PlaceholderValue::values() const {
  // @@protoc_insertion_point(field_list:milvus.proto.common.PlaceholderValue.values)
  return _impl_.values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
PlaceholderValue::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.common.PlaceholderValue.values)
  return &_impl_.values_;
}

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

// PlaceholderGroup

// repeated .milvus.proto.common.PlaceholderValue placeholders = 1;
inline int PlaceholderGroup::_internal_placeholders_size() const {
  return _impl_.placeholders_.size();
}
inline int PlaceholderGroup::placeholders_size() const {
  return _internal_placeholders_size();
}
inline void PlaceholderGroup::clear_placeholders() {
  _impl_.placeholders_.Clear();
}
inline ::milvus::proto::common::PlaceholderValue* PlaceholderGroup::mutable_placeholders(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.PlaceholderGroup.placeholders)
  return _impl_.placeholders_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue >*
PlaceholderGroup::mutable_placeholders() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.common.PlaceholderGroup.placeholders)
  return &_impl_.placeholders_;
}
inline const ::milvus::proto::common::PlaceholderValue& PlaceholderGroup::_internal_placeholders(int index) const {
  return _impl_.placeholders_.Get(index);
}
inline const ::milvus::proto::common::PlaceholderValue& PlaceholderGroup::placeholders(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.PlaceholderGroup.placeholders)
  return _internal_placeholders(index);
}
inline ::milvus::proto::common::PlaceholderValue* PlaceholderGroup::_internal_add_placeholders() {
  return _impl_.placeholders_.Add();
}
inline ::milvus::proto::common::PlaceholderValue* PlaceholderGroup::add_placeholders() {
  ::milvus::proto::common::PlaceholderValue* _add = _internal_add_placeholders();
  // @@protoc_insertion_point(field_add:milvus.proto.common.PlaceholderGroup.placeholders)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::PlaceholderValue >&
PlaceholderGroup::placeholders() const {
  // @@protoc_insertion_point(field_list:milvus.proto.common.PlaceholderGroup.placeholders)
  return _impl_.placeholders_;
}

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

// Address

// string ip = 1;
inline void Address::clear_ip() {
  _impl_.ip_.ClearToEmpty();
}
inline const std::string& Address::ip() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.Address.ip)
  return _internal_ip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Address::set_ip(ArgT0&& arg0, ArgT... args) {
 
 _impl_.ip_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.common.Address.ip)
}
inline std::string* Address::mutable_ip() {
  std::string* _s = _internal_mutable_ip();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.Address.ip)
  return _s;
}
inline const std::string& Address::_internal_ip() const {
  return _impl_.ip_.Get();
}
inline void Address::_internal_set_ip(const std::string& value) {
  
  _impl_.ip_.Set(value, GetArenaForAllocation());
}
inline std::string* Address::_internal_mutable_ip() {
  
  return _impl_.ip_.Mutable(GetArenaForAllocation());
}
inline std::string* Address::release_ip() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.Address.ip)
  return _impl_.ip_.Release();
}
inline void Address::set_allocated_ip(std::string* ip) {
  if (ip != nullptr) {
    
  } else {
    
  }
  _impl_.ip_.SetAllocated(ip, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ip_.IsDefault()) {
    _impl_.ip_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.Address.ip)
}

// int64 port = 2;
inline void Address::clear_port() {
  _impl_.port_ = int64_t{0};
}
inline int64_t Address::_internal_port() const {
  return _impl_.port_;
}
inline int64_t Address::port() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.Address.port)
  return _internal_port();
}
inline void Address::_internal_set_port(int64_t value) {
  
  _impl_.port_ = value;
}
inline void Address::set_port(int64_t value) {
  _internal_set_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() {
  _impl_.msg_type_ = 0;
}
inline ::milvus::proto::common::MsgType MsgBase::_internal_msg_type() const {
  return static_cast< ::milvus::proto::common::MsgType >(_impl_.msg_type_);
}
inline ::milvus::proto::common::MsgType MsgBase::msg_type() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.msg_type)
  return _internal_msg_type();
}
inline void MsgBase::_internal_set_msg_type(::milvus::proto::common::MsgType value) {
  
  _impl_.msg_type_ = value;
}
inline void MsgBase::set_msg_type(::milvus::proto::common::MsgType value) {
  _internal_set_msg_type(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.msg_type)
}

// int64 msgID = 2;
inline void MsgBase::clear_msgid() {
  _impl_.msgid_ = int64_t{0};
}
inline int64_t MsgBase::_internal_msgid() const {
  return _impl_.msgid_;
}
inline int64_t MsgBase::msgid() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.msgID)
  return _internal_msgid();
}
inline void MsgBase::_internal_set_msgid(int64_t value) {
  
  _impl_.msgid_ = value;
}
inline void MsgBase::set_msgid(int64_t value) {
  _internal_set_msgid(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.msgID)
}

// uint64 timestamp = 3;
inline void MsgBase::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
}
inline uint64_t MsgBase::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t MsgBase::timestamp() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.timestamp)
  return _internal_timestamp();
}
inline void MsgBase::_internal_set_timestamp(uint64_t value) {
  
  _impl_.timestamp_ = value;
}
inline void MsgBase::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.timestamp)
}

// int64 sourceID = 4;
inline void MsgBase::clear_sourceid() {
  _impl_.sourceid_ = int64_t{0};
}
inline int64_t MsgBase::_internal_sourceid() const {
  return _impl_.sourceid_;
}
inline int64_t MsgBase::sourceid() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.sourceID)
  return _internal_sourceid();
}
inline void MsgBase::_internal_set_sourceid(int64_t value) {
  
  _impl_.sourceid_ = value;
}
inline void MsgBase::set_sourceid(int64_t value) {
  _internal_set_sourceid(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.sourceID)
}

// int64 targetID = 5;
inline void MsgBase::clear_targetid() {
  _impl_.targetid_ = int64_t{0};
}
inline int64_t MsgBase::_internal_targetid() const {
  return _impl_.targetid_;
}
inline int64_t MsgBase::targetid() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.MsgBase.targetID)
  return _internal_targetid();
}
inline void MsgBase::_internal_set_targetid(int64_t value) {
  
  _impl_.targetid_ = value;
}
inline void MsgBase::set_targetid(int64_t value) {
  _internal_set_targetid(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.MsgBase.targetID)
}

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

// MsgHeader

// .milvus.proto.common.MsgBase base = 1;
inline bool MsgHeader::_internal_has_base() const {
  return this != internal_default_instance() && _impl_.base_ != nullptr;
}
inline bool MsgHeader::has_base() const {
  return _internal_has_base();
}
inline void MsgHeader::clear_base() {
  if (GetArenaForAllocation() == nullptr && _impl_.base_ != nullptr) {
    delete _impl_.base_;
  }
  _impl_.base_ = nullptr;
}
inline const ::milvus::proto::common::MsgBase& MsgHeader::_internal_base() const {
  const ::milvus::proto::common::MsgBase* p = _impl_.base_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::common::MsgBase&>(
      ::milvus::proto::common::_MsgBase_default_instance_);
}
inline const ::milvus::proto::common::MsgBase& MsgHeader::base() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.MsgHeader.base)
  return _internal_base();
}
inline void MsgHeader::unsafe_arena_set_allocated_base(
    ::milvus::proto::common::MsgBase* base) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.base_);
  }
  _impl_.base_ = base;
  if (base) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.common.MsgHeader.base)
}
inline ::milvus::proto::common::MsgBase* MsgHeader::release_base() {
  
  ::milvus::proto::common::MsgBase* temp = _impl_.base_;
  _impl_.base_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::milvus::proto::common::MsgBase* MsgHeader::unsafe_arena_release_base() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.MsgHeader.base)
  
  ::milvus::proto::common::MsgBase* temp = _impl_.base_;
  _impl_.base_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::MsgBase* MsgHeader::_internal_mutable_base() {
  
  if (_impl_.base_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaForAllocation());
    _impl_.base_ = p;
  }
  return _impl_.base_;
}
inline ::milvus::proto::common::MsgBase* MsgHeader::mutable_base() {
  ::milvus::proto::common::MsgBase* _msg = _internal_mutable_base();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.MsgHeader.base)
  return _msg;
}
inline void MsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.base_;
  }
  if (base) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(base);
    if (message_arena != submessage_arena) {
      base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, base, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.base_ = base;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.MsgHeader.base)
}

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

// DMLMsgHeader

// .milvus.proto.common.MsgBase base = 1;
inline bool DMLMsgHeader::_internal_has_base() const {
  return this != internal_default_instance() && _impl_.base_ != nullptr;
}
inline bool DMLMsgHeader::has_base() const {
  return _internal_has_base();
}
inline void DMLMsgHeader::clear_base() {
  if (GetArenaForAllocation() == nullptr && _impl_.base_ != nullptr) {
    delete _impl_.base_;
  }
  _impl_.base_ = nullptr;
}
inline const ::milvus::proto::common::MsgBase& DMLMsgHeader::_internal_base() const {
  const ::milvus::proto::common::MsgBase* p = _impl_.base_;
  return p != nullptr ? *p : reinterpret_cast<const ::milvus::proto::common::MsgBase&>(
      ::milvus::proto::common::_MsgBase_default_instance_);
}
inline const ::milvus::proto::common::MsgBase& DMLMsgHeader::base() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.base)
  return _internal_base();
}
inline void DMLMsgHeader::unsafe_arena_set_allocated_base(
    ::milvus::proto::common::MsgBase* base) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.base_);
  }
  _impl_.base_ = base;
  if (base) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:milvus.proto.common.DMLMsgHeader.base)
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::release_base() {
  
  ::milvus::proto::common::MsgBase* temp = _impl_.base_;
  _impl_.base_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::unsafe_arena_release_base() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.base)
  
  ::milvus::proto::common::MsgBase* temp = _impl_.base_;
  _impl_.base_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::_internal_mutable_base() {
  
  if (_impl_.base_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaForAllocation());
    _impl_.base_ = p;
  }
  return _impl_.base_;
}
inline ::milvus::proto::common::MsgBase* DMLMsgHeader::mutable_base() {
  ::milvus::proto::common::MsgBase* _msg = _internal_mutable_base();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.base)
  return _msg;
}
inline void DMLMsgHeader::set_allocated_base(::milvus::proto::common::MsgBase* base) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.base_;
  }
  if (base) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(base);
    if (message_arena != submessage_arena) {
      base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, base, submessage_arena);
    }
    
  } else {
    
  }
  _impl_.base_ = base;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.DMLMsgHeader.base)
}

// string shardName = 2;
inline void DMLMsgHeader::clear_shardname() {
  _impl_.shardname_.ClearToEmpty();
}
inline const std::string& DMLMsgHeader::shardname() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.DMLMsgHeader.shardName)
  return _internal_shardname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DMLMsgHeader::set_shardname(ArgT0&& arg0, ArgT... args) {
 
 _impl_.shardname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:milvus.proto.common.DMLMsgHeader.shardName)
}
inline std::string* DMLMsgHeader::mutable_shardname() {
  std::string* _s = _internal_mutable_shardname();
  // @@protoc_insertion_point(field_mutable:milvus.proto.common.DMLMsgHeader.shardName)
  return _s;
}
inline const std::string& DMLMsgHeader::_internal_shardname() const {
  return _impl_.shardname_.Get();
}
inline void DMLMsgHeader::_internal_set_shardname(const std::string& value) {
  
  _impl_.shardname_.Set(value, GetArenaForAllocation());
}
inline std::string* DMLMsgHeader::_internal_mutable_shardname() {
  
  return _impl_.shardname_.Mutable(GetArenaForAllocation());
}
inline std::string* DMLMsgHeader::release_shardname() {
  // @@protoc_insertion_point(field_release:milvus.proto.common.DMLMsgHeader.shardName)
  return _impl_.shardname_.Release();
}
inline void DMLMsgHeader::set_allocated_shardname(std::string* shardname) {
  if (shardname != nullptr) {
    
  } else {
    
  }
  _impl_.shardname_.SetAllocated(shardname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.shardname_.IsDefault()) {
    _impl_.shardname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.common.DMLMsgHeader.shardName)
}

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

// PrivilegeExt

// .milvus.proto.common.ObjectType object_type = 1;
inline void PrivilegeExt::clear_object_type() {
  _impl_.object_type_ = 0;
}
inline ::milvus::proto::common::ObjectType PrivilegeExt::_internal_object_type() const {
  return static_cast< ::milvus::proto::common::ObjectType >(_impl_.object_type_);
}
inline ::milvus::proto::common::ObjectType PrivilegeExt::object_type() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.object_type)
  return _internal_object_type();
}
inline void PrivilegeExt::_internal_set_object_type(::milvus::proto::common::ObjectType value) {
  
  _impl_.object_type_ = value;
}
inline void PrivilegeExt::set_object_type(::milvus::proto::common::ObjectType value) {
  _internal_set_object_type(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.object_type)
}

// .milvus.proto.common.ObjectPrivilege object_privilege = 2;
inline void PrivilegeExt::clear_object_privilege() {
  _impl_.object_privilege_ = 0;
}
inline ::milvus::proto::common::ObjectPrivilege PrivilegeExt::_internal_object_privilege() const {
  return static_cast< ::milvus::proto::common::ObjectPrivilege >(_impl_.object_privilege_);
}
inline ::milvus::proto::common::ObjectPrivilege PrivilegeExt::object_privilege() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.object_privilege)
  return _internal_object_privilege();
}
inline void PrivilegeExt::_internal_set_object_privilege(::milvus::proto::common::ObjectPrivilege value) {
  
  _impl_.object_privilege_ = value;
}
inline void PrivilegeExt::set_object_privilege(::milvus::proto::common::ObjectPrivilege value) {
  _internal_set_object_privilege(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.object_privilege)
}

// int32 object_name_index = 3;
inline void PrivilegeExt::clear_object_name_index() {
  _impl_.object_name_index_ = 0;
}
inline int32_t PrivilegeExt::_internal_object_name_index() const {
  return _impl_.object_name_index_;
}
inline int32_t PrivilegeExt::object_name_index() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.object_name_index)
  return _internal_object_name_index();
}
inline void PrivilegeExt::_internal_set_object_name_index(int32_t value) {
  
  _impl_.object_name_index_ = value;
}
inline void PrivilegeExt::set_object_name_index(int32_t value) {
  _internal_set_object_name_index(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.object_name_index)
}

// int32 object_name_indexs = 4;
inline void PrivilegeExt::clear_object_name_indexs() {
  _impl_.object_name_indexs_ = 0;
}
inline int32_t PrivilegeExt::_internal_object_name_indexs() const {
  return _impl_.object_name_indexs_;
}
inline int32_t PrivilegeExt::object_name_indexs() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.PrivilegeExt.object_name_indexs)
  return _internal_object_name_indexs();
}
inline void PrivilegeExt::_internal_set_object_name_indexs(int32_t value) {
  
  _impl_.object_name_indexs_ = value;
}
inline void PrivilegeExt::set_object_name_indexs(int32_t value) {
  _internal_set_object_name_indexs(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.PrivilegeExt.object_name_indexs)
}

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

// SegmentStats

// int64 SegmentID = 1;
inline void SegmentStats::clear_segmentid() {
  _impl_.segmentid_ = int64_t{0};
}
inline int64_t SegmentStats::_internal_segmentid() const {
  return _impl_.segmentid_;
}
inline int64_t SegmentStats::segmentid() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.SegmentStats.SegmentID)
  return _internal_segmentid();
}
inline void SegmentStats::_internal_set_segmentid(int64_t value) {
  
  _impl_.segmentid_ = value;
}
inline void SegmentStats::set_segmentid(int64_t value) {
  _internal_set_segmentid(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.SegmentStats.SegmentID)
}

// int64 NumRows = 2;
inline void SegmentStats::clear_numrows() {
  _impl_.numrows_ = int64_t{0};
}
inline int64_t SegmentStats::_internal_numrows() const {
  return _impl_.numrows_;
}
inline int64_t SegmentStats::numrows() const {
  // @@protoc_insertion_point(field_get:milvus.proto.common.SegmentStats.NumRows)
  return _internal_numrows();
}
inline void SegmentStats::_internal_set_numrows(int64_t value) {
  
  _impl_.numrows_ = value;
}
inline void SegmentStats::set_numrows(int64_t value) {
  _internal_set_numrows(value);
  // @@protoc_insertion_point(field_set:milvus.proto.common.SegmentStats.NumRows)
}

#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::PlaceholderType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::PlaceholderType>() {
  return ::milvus::proto::common::PlaceholderType_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();
}
template <> struct is_proto_enum< ::milvus::proto::common::ObjectType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ObjectType>() {
  return ::milvus::proto::common::ObjectType_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::ObjectPrivilege> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ObjectPrivilege>() {
  return ::milvus::proto::common::ObjectPrivilege_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::StateCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::StateCode>() {
  return ::milvus::proto::common::StateCode_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::LoadState> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::LoadState>() {
  return ::milvus::proto::common::LoadState_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_common_2eproto
