// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: entity.proto

#ifndef PROTOBUF_entity_2eproto__INCLUDED
#define PROTOBUF_entity_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 2004000
#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 2004001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include "common.pb.h"
#include "services.pb.h"
// @@protoc_insertion_point(includes)

namespace com {
namespace telenav {
namespace proto {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_entity_2eproto();
void protobuf_AssignDesc_entity_2eproto();
void protobuf_ShutdownFile_entity_2eproto();

class EntitySearchRequest;
class EntitySearchResponse;
class SearchContext;
class QueryResolution;
class QuerySuggestion;
class SearchResult;
class Entity;
class EntityDetail;
class EntityDetailRequest;
class EntityDetailResponse;
class EntitySuggestionsRequest;
class EntitySuggestionsResponse;
class EntitySuggestionsResult;

enum EntityType {
  ADDRESS = 1,
  POI = 2,
  EVENT = 3
};
bool EntityType_IsValid(int value);
const EntityType EntityType_MIN = ADDRESS;
const EntityType EntityType_MAX = EVENT;
const int EntityType_ARRAYSIZE = EntityType_MAX + 1;

enum SuggestionsType {
  CITY_STATE_SUGGESTIONS = 1,
  ALL_SUGGESTIONS = 100
};
bool SuggestionsType_IsValid(int value);
const SuggestionsType SuggestionsType_MIN = CITY_STATE_SUGGESTIONS;
const SuggestionsType SuggestionsType_MAX = ALL_SUGGESTIONS;
const int SuggestionsType_ARRAYSIZE = SuggestionsType_MAX + 1;

enum EntityServiceStatus {
  OK = 12200,
  ZERO_RESULTS = 12204,
  ENTITY_MOVED = 12301,
  INVALID_REQUEST = 12400,
  UNKNOWN_ENTITY = 12404,
  UNKNOWN_ERROR = 12500
};
bool EntityServiceStatus_IsValid(int value);
const EntityServiceStatus EntityServiceStatus_MIN = OK;
const EntityServiceStatus EntityServiceStatus_MAX = UNKNOWN_ERROR;
const int EntityServiceStatus_ARRAYSIZE = EntityServiceStatus_MAX + 1;

enum EntitySearchSubStatus {
  ADDRESS_MULTI = 12220,
  ADDRESS_EXACTLY = 12221,
  ADDRESS_LATLON = 12222,
  POI_BY_DEFAULT_LOC = 12230,
  POI_BY_USER_INPUT = 12231,
  POI_LANDMARK = 12232,
  POI_AIRPORT = 12235,
  SUGGESTIONS = 12240
};
bool EntitySearchSubStatus_IsValid(int value);
const EntitySearchSubStatus EntitySearchSubStatus_MIN = ADDRESS_MULTI;
const EntitySearchSubStatus EntitySearchSubStatus_MAX = SUGGESTIONS;
const int EntitySearchSubStatus_ARRAYSIZE = EntitySearchSubStatus_MAX + 1;

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

class EntitySearchRequest : public ::google::protobuf::MessageLite {
 public:
  EntitySearchRequest();
  virtual ~EntitySearchRequest();
  
  EntitySearchRequest(const EntitySearchRequest& from);
  
  inline EntitySearchRequest& operator=(const EntitySearchRequest& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const EntitySearchRequest& default_instance();
  
  void Swap(EntitySearchRequest* other);
  
  // implements Message ----------------------------------------------
  
  EntitySearchRequest* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EntitySearchRequest& from);
  void MergeFrom(const EntitySearchRequest& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string request_id = 1;
  inline bool has_request_id() const;
  inline void clear_request_id();
  static const int kRequestIdFieldNumber = 1;
  inline const ::std::string& request_id() const;
  inline void set_request_id(const ::std::string& value);
  inline void set_request_id(const char* value);
  inline void set_request_id(const char* value, size_t size);
  inline ::std::string* mutable_request_id();
  inline ::std::string* release_request_id();
  
  // required .com.telenav.proto.Context context = 2;
  inline bool has_context() const;
  inline void clear_context();
  static const int kContextFieldNumber = 2;
  inline const ::com::telenav::proto::Context& context() const;
  inline ::com::telenav::proto::Context* mutable_context();
  inline ::com::telenav::proto::Context* release_context();
  
  // optional string query = 11;
  inline bool has_query() const;
  inline void clear_query();
  static const int kQueryFieldNumber = 11;
  inline const ::std::string& query() const;
  inline void set_query(const ::std::string& value);
  inline void set_query(const char* value);
  inline void set_query(const char* value, size_t size);
  inline ::std::string* mutable_query();
  inline ::std::string* release_query();
  
  // optional string current_location = 12;
  inline bool has_current_location() const;
  inline void clear_current_location();
  static const int kCurrentLocationFieldNumber = 12;
  inline const ::std::string& current_location() const;
  inline void set_current_location(const ::std::string& value);
  inline void set_current_location(const char* value);
  inline void set_current_location(const char* value, size_t size);
  inline ::std::string* mutable_current_location();
  inline ::std::string* release_current_location();
  
  // repeated .com.telenav.proto.LatLon route_point = 13;
  inline int route_point_size() const;
  inline void clear_route_point();
  static const int kRoutePointFieldNumber = 13;
  inline const ::com::telenav::proto::LatLon& route_point(int index) const;
  inline ::com::telenav::proto::LatLon* mutable_route_point(int index);
  inline ::com::telenav::proto::LatLon* add_route_point();
  inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon >&
      route_point() const;
  inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon >*
      mutable_route_point();
  
  // repeated string category = 21;
  inline int category_size() const;
  inline void clear_category();
  static const int kCategoryFieldNumber = 21;
  inline const ::std::string& category(int index) const;
  inline ::std::string* mutable_category(int index);
  inline void set_category(int index, const ::std::string& value);
  inline void set_category(int index, const char* value);
  inline void set_category(int index, const char* value, size_t size);
  inline ::std::string* add_category();
  inline void add_category(const ::std::string& value);
  inline void add_category(const char* value);
  inline void add_category(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& category() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_category();
  
  // optional string entity_source = 30;
  inline bool has_entity_source() const;
  inline void clear_entity_source();
  static const int kEntitySourceFieldNumber = 30;
  inline const ::std::string& entity_source() const;
  inline void set_entity_source(const ::std::string& value);
  inline void set_entity_source(const char* value);
  inline void set_entity_source(const char* value, size_t size);
  inline ::std::string* mutable_entity_source();
  inline ::std::string* release_entity_source();
  
  // optional string geo_source = 31;
  inline bool has_geo_source() const;
  inline void clear_geo_source();
  static const int kGeoSourceFieldNumber = 31;
  inline const ::std::string& geo_source() const;
  inline void set_geo_source(const ::std::string& value);
  inline void set_geo_source(const char* value);
  inline void set_geo_source(const char* value, size_t size);
  inline ::std::string* mutable_geo_source();
  inline ::std::string* release_geo_source();
  
  // optional int32 offset = 100;
  inline bool has_offset() const;
  inline void clear_offset();
  static const int kOffsetFieldNumber = 100;
  inline ::google::protobuf::int32 offset() const;
  inline void set_offset(::google::protobuf::int32 value);
  
  // optional int32 limit = 101;
  inline bool has_limit() const;
  inline void clear_limit();
  static const int kLimitFieldNumber = 101;
  inline ::google::protobuf::int32 limit() const;
  inline void set_limit(::google::protobuf::int32 value);
  
  // optional string rank_by = 102;
  inline bool has_rank_by() const;
  inline void clear_rank_by();
  static const int kRankByFieldNumber = 102;
  inline const ::std::string& rank_by() const;
  inline void set_rank_by(const ::std::string& value);
  inline void set_rank_by(const char* value);
  inline void set_rank_by(const char* value, size_t size);
  inline ::std::string* mutable_rank_by();
  inline ::std::string* release_rank_by();
  
  // optional string lang = 120;
  inline bool has_lang() const;
  inline void clear_lang();
  static const int kLangFieldNumber = 120;
  inline const ::std::string& lang() const;
  inline void set_lang(const ::std::string& value);
  inline void set_lang(const char* value);
  inline void set_lang(const char* value, size_t size);
  inline ::std::string* mutable_lang();
  inline ::std::string* release_lang();
  
  // optional string country = 121;
  inline bool has_country() const;
  inline void clear_country();
  static const int kCountryFieldNumber = 121;
  inline const ::std::string& country() const;
  inline void set_country(const ::std::string& value);
  inline void set_country(const char* value);
  inline void set_country(const char* value, size_t size);
  inline ::std::string* mutable_country();
  inline ::std::string* release_country();
  
  // optional string search_context = 150;
  inline bool has_search_context() const;
  inline void clear_search_context();
  static const int kSearchContextFieldNumber = 150;
  inline const ::std::string& search_context() const;
  inline void set_search_context(const ::std::string& value);
  inline void set_search_context(const char* value);
  inline void set_search_context(const char* value, size_t size);
  inline ::std::string* mutable_search_context();
  inline ::std::string* release_search_context();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.EntitySearchRequest)
 private:
  inline void set_has_request_id();
  inline void clear_has_request_id();
  inline void set_has_context();
  inline void clear_has_context();
  inline void set_has_query();
  inline void clear_has_query();
  inline void set_has_current_location();
  inline void clear_has_current_location();
  inline void set_has_entity_source();
  inline void clear_has_entity_source();
  inline void set_has_geo_source();
  inline void clear_has_geo_source();
  inline void set_has_offset();
  inline void clear_has_offset();
  inline void set_has_limit();
  inline void clear_has_limit();
  inline void set_has_rank_by();
  inline void clear_has_rank_by();
  inline void set_has_lang();
  inline void clear_has_lang();
  inline void set_has_country();
  inline void clear_has_country();
  inline void set_has_search_context();
  inline void clear_has_search_context();
  
  ::std::string* request_id_;
  ::com::telenav::proto::Context* context_;
  ::std::string* query_;
  ::std::string* current_location_;
  ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon > route_point_;
  ::google::protobuf::RepeatedPtrField< ::std::string> category_;
  ::std::string* entity_source_;
  ::std::string* geo_source_;
  ::google::protobuf::int32 offset_;
  ::google::protobuf::int32 limit_;
  ::std::string* rank_by_;
  ::std::string* lang_;
  ::std::string* country_;
  ::std::string* search_context_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(14 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static EntitySearchRequest* default_instance_;
};
// -------------------------------------------------------------------

class EntitySearchResponse : public ::google::protobuf::MessageLite {
 public:
  EntitySearchResponse();
  virtual ~EntitySearchResponse();
  
  EntitySearchResponse(const EntitySearchResponse& from);
  
  inline EntitySearchResponse& operator=(const EntitySearchResponse& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const EntitySearchResponse& default_instance();
  
  void Swap(EntitySearchResponse* other);
  
  // implements Message ----------------------------------------------
  
  EntitySearchResponse* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EntitySearchResponse& from);
  void MergeFrom(const EntitySearchResponse& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional .com.telenav.proto.ServiceStatus status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline const ::com::telenav::proto::ServiceStatus& status() const;
  inline ::com::telenav::proto::ServiceStatus* mutable_status();
  inline ::com::telenav::proto::ServiceStatus* release_status();
  
  // optional .com.telenav.proto.EntitySearchSubStatus sub_status = 2;
  inline bool has_sub_status() const;
  inline void clear_sub_status();
  static const int kSubStatusFieldNumber = 2;
  inline com::telenav::proto::EntitySearchSubStatus sub_status() const;
  inline void set_sub_status(com::telenav::proto::EntitySearchSubStatus value);
  
  // optional .com.telenav.proto.SearchContext search_context = 9;
  inline bool has_search_context() const;
  inline void clear_search_context();
  static const int kSearchContextFieldNumber = 9;
  inline const ::com::telenav::proto::SearchContext& search_context() const;
  inline ::com::telenav::proto::SearchContext* mutable_search_context();
  inline ::com::telenav::proto::SearchContext* release_search_context();
  
  // optional .com.telenav.proto.QueryResolution query_resolution = 10;
  inline bool has_query_resolution() const;
  inline void clear_query_resolution();
  static const int kQueryResolutionFieldNumber = 10;
  inline const ::com::telenav::proto::QueryResolution& query_resolution() const;
  inline ::com::telenav::proto::QueryResolution* mutable_query_resolution();
  inline ::com::telenav::proto::QueryResolution* release_query_resolution();
  
  // optional int32 total_results = 20;
  inline bool has_total_results() const;
  inline void clear_total_results();
  static const int kTotalResultsFieldNumber = 20;
  inline ::google::protobuf::int32 total_results() const;
  inline void set_total_results(::google::protobuf::int32 value);
  
  // repeated .com.telenav.proto.SearchResult result = 30;
  inline int result_size() const;
  inline void clear_result();
  static const int kResultFieldNumber = 30;
  inline const ::com::telenav::proto::SearchResult& result(int index) const;
  inline ::com::telenav::proto::SearchResult* mutable_result(int index);
  inline ::com::telenav::proto::SearchResult* add_result();
  inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::SearchResult >&
      result() const;
  inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::SearchResult >*
      mutable_result();
  
  // repeated .com.telenav.proto.QuerySuggestion suggestion = 50;
  inline int suggestion_size() const;
  inline void clear_suggestion();
  static const int kSuggestionFieldNumber = 50;
  inline const ::com::telenav::proto::QuerySuggestion& suggestion(int index) const;
  inline ::com::telenav::proto::QuerySuggestion* mutable_suggestion(int index);
  inline ::com::telenav::proto::QuerySuggestion* add_suggestion();
  inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::QuerySuggestion >&
      suggestion() const;
  inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::QuerySuggestion >*
      mutable_suggestion();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.EntitySearchResponse)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  inline void set_has_sub_status();
  inline void clear_has_sub_status();
  inline void set_has_search_context();
  inline void clear_has_search_context();
  inline void set_has_query_resolution();
  inline void clear_has_query_resolution();
  inline void set_has_total_results();
  inline void clear_has_total_results();
  
  ::com::telenav::proto::ServiceStatus* status_;
  ::com::telenav::proto::SearchContext* search_context_;
  int sub_status_;
  ::google::protobuf::int32 total_results_;
  ::com::telenav::proto::QueryResolution* query_resolution_;
  ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::SearchResult > result_;
  ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::QuerySuggestion > suggestion_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static EntitySearchResponse* default_instance_;
};
// -------------------------------------------------------------------

class SearchContext : public ::google::protobuf::MessageLite {
 public:
  SearchContext();
  virtual ~SearchContext();
  
  SearchContext(const SearchContext& from);
  
  inline SearchContext& operator=(const SearchContext& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const SearchContext& default_instance();
  
  void Swap(SearchContext* other);
  
  // implements Message ----------------------------------------------
  
  SearchContext* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SearchContext& from);
  void MergeFrom(const SearchContext& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string previous = 1;
  inline bool has_previous() const;
  inline void clear_previous();
  static const int kPreviousFieldNumber = 1;
  inline const ::std::string& previous() const;
  inline void set_previous(const ::std::string& value);
  inline void set_previous(const char* value);
  inline void set_previous(const char* value, size_t size);
  inline ::std::string* mutable_previous();
  inline ::std::string* release_previous();
  
  // optional string next = 2;
  inline bool has_next() const;
  inline void clear_next();
  static const int kNextFieldNumber = 2;
  inline const ::std::string& next() const;
  inline void set_next(const ::std::string& value);
  inline void set_next(const char* value);
  inline void set_next(const char* value, size_t size);
  inline ::std::string* mutable_next();
  inline ::std::string* release_next();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.SearchContext)
 private:
  inline void set_has_previous();
  inline void clear_has_previous();
  inline void set_has_next();
  inline void clear_has_next();
  
  ::std::string* previous_;
  ::std::string* next_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static SearchContext* default_instance_;
};
// -------------------------------------------------------------------

class QueryResolution : public ::google::protobuf::MessageLite {
 public:
  QueryResolution();
  virtual ~QueryResolution();
  
  QueryResolution(const QueryResolution& from);
  
  inline QueryResolution& operator=(const QueryResolution& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const QueryResolution& default_instance();
  
  void Swap(QueryResolution* other);
  
  // implements Message ----------------------------------------------
  
  QueryResolution* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const QueryResolution& from);
  void MergeFrom(const QueryResolution& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string query_type = 1;
  inline bool has_query_type() const;
  inline void clear_query_type();
  static const int kQueryTypeFieldNumber = 1;
  inline const ::std::string& query_type() const;
  inline void set_query_type(const ::std::string& value);
  inline void set_query_type(const char* value);
  inline void set_query_type(const char* value, size_t size);
  inline ::std::string* mutable_query_type();
  inline ::std::string* release_query_type();
  
  // optional string what = 2;
  inline bool has_what() const;
  inline void clear_what();
  static const int kWhatFieldNumber = 2;
  inline const ::std::string& what() const;
  inline void set_what(const ::std::string& value);
  inline void set_what(const char* value);
  inline void set_what(const char* value, size_t size);
  inline ::std::string* mutable_what();
  inline ::std::string* release_what();
  
  // optional string where = 3;
  inline bool has_where() const;
  inline void clear_where();
  static const int kWhereFieldNumber = 3;
  inline const ::std::string& where() const;
  inline void set_where(const ::std::string& value);
  inline void set_where(const char* value);
  inline void set_where(const char* value, size_t size);
  inline ::std::string* mutable_where();
  inline ::std::string* release_where();
  
  // repeated string category = 5;
  inline int category_size() const;
  inline void clear_category();
  static const int kCategoryFieldNumber = 5;
  inline const ::std::string& category(int index) const;
  inline ::std::string* mutable_category(int index);
  inline void set_category(int index, const ::std::string& value);
  inline void set_category(int index, const char* value);
  inline void set_category(int index, const char* value, size_t size);
  inline ::std::string* add_category();
  inline void add_category(const ::std::string& value);
  inline void add_category(const char* value);
  inline void add_category(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& category() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_category();
  
  // optional string rewritten_query = 10;
  inline bool has_rewritten_query() const;
  inline void clear_rewritten_query();
  static const int kRewrittenQueryFieldNumber = 10;
  inline const ::std::string& rewritten_query() const;
  inline void set_rewritten_query(const ::std::string& value);
  inline void set_rewritten_query(const char* value);
  inline void set_rewritten_query(const char* value, size_t size);
  inline ::std::string* mutable_rewritten_query();
  inline ::std::string* release_rewritten_query();
  
  // optional .com.telenav.proto.LatLon center_geocode = 20;
  inline bool has_center_geocode() const;
  inline void clear_center_geocode();
  static const int kCenterGeocodeFieldNumber = 20;
  inline const ::com::telenav::proto::LatLon& center_geocode() const;
  inline ::com::telenav::proto::LatLon* mutable_center_geocode();
  inline ::com::telenav::proto::LatLon* release_center_geocode();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.QueryResolution)
 private:
  inline void set_has_query_type();
  inline void clear_has_query_type();
  inline void set_has_what();
  inline void clear_has_what();
  inline void set_has_where();
  inline void clear_has_where();
  inline void set_has_rewritten_query();
  inline void clear_has_rewritten_query();
  inline void set_has_center_geocode();
  inline void clear_has_center_geocode();
  
  ::std::string* query_type_;
  ::std::string* what_;
  ::std::string* where_;
  ::google::protobuf::RepeatedPtrField< ::std::string> category_;
  ::std::string* rewritten_query_;
  ::com::telenav::proto::LatLon* center_geocode_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static QueryResolution* default_instance_;
};
// -------------------------------------------------------------------

class QuerySuggestion : public ::google::protobuf::MessageLite {
 public:
  QuerySuggestion();
  virtual ~QuerySuggestion();
  
  QuerySuggestion(const QuerySuggestion& from);
  
  inline QuerySuggestion& operator=(const QuerySuggestion& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const QuerySuggestion& default_instance();
  
  void Swap(QuerySuggestion* other);
  
  // implements Message ----------------------------------------------
  
  QuerySuggestion* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const QuerySuggestion& from);
  void MergeFrom(const QuerySuggestion& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string display_label = 1;
  inline bool has_display_label() const;
  inline void clear_display_label();
  static const int kDisplayLabelFieldNumber = 1;
  inline const ::std::string& display_label() const;
  inline void set_display_label(const ::std::string& value);
  inline void set_display_label(const char* value);
  inline void set_display_label(const char* value, size_t size);
  inline ::std::string* mutable_display_label();
  inline ::std::string* release_display_label();
  
  // optional string query = 2;
  inline bool has_query() const;
  inline void clear_query();
  static const int kQueryFieldNumber = 2;
  inline const ::std::string& query() const;
  inline void set_query(const ::std::string& value);
  inline void set_query(const char* value);
  inline void set_query(const char* value, size_t size);
  inline ::std::string* mutable_query();
  inline ::std::string* release_query();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.QuerySuggestion)
 private:
  inline void set_has_display_label();
  inline void clear_has_display_label();
  inline void set_has_query();
  inline void clear_has_query();
  
  ::std::string* display_label_;
  ::std::string* query_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static QuerySuggestion* default_instance_;
};
// -------------------------------------------------------------------

class SearchResult : public ::google::protobuf::MessageLite {
 public:
  SearchResult();
  virtual ~SearchResult();
  
  SearchResult(const SearchResult& from);
  
  inline SearchResult& operator=(const SearchResult& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const SearchResult& default_instance();
  
  void Swap(SearchResult* other);
  
  // implements Message ----------------------------------------------
  
  SearchResult* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const SearchResult& from);
  void MergeFrom(const SearchResult& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .com.telenav.proto.Entity entity = 1;
  inline bool has_entity() const;
  inline void clear_entity();
  static const int kEntityFieldNumber = 1;
  inline const ::com::telenav::proto::Entity& entity() const;
  inline ::com::telenav::proto::Entity* mutable_entity();
  inline ::com::telenav::proto::Entity* release_entity();
  
  // optional double score = 10;
  inline bool has_score() const;
  inline void clear_score();
  static const int kScoreFieldNumber = 10;
  inline double score() const;
  inline void set_score(double value);
  
  // optional int32 distance = 11;
  inline bool has_distance() const;
  inline void clear_distance();
  static const int kDistanceFieldNumber = 11;
  inline ::google::protobuf::int32 distance() const;
  inline void set_distance(::google::protobuf::int32 value);
  
  // repeated .com.telenav.proto.Facet facet = 20;
  inline int facet_size() const;
  inline void clear_facet();
  static const int kFacetFieldNumber = 20;
  inline const ::com::telenav::proto::Facet& facet(int index) const;
  inline ::com::telenav::proto::Facet* mutable_facet(int index);
  inline ::com::telenav::proto::Facet* add_facet();
  inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet >&
      facet() const;
  inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet >*
      mutable_facet();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.SearchResult)
 private:
  inline void set_has_entity();
  inline void clear_has_entity();
  inline void set_has_score();
  inline void clear_has_score();
  inline void set_has_distance();
  inline void clear_has_distance();
  
  ::com::telenav::proto::Entity* entity_;
  double score_;
  ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet > facet_;
  ::google::protobuf::int32 distance_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static SearchResult* default_instance_;
};
// -------------------------------------------------------------------

class Entity : public ::google::protobuf::MessageLite {
 public:
  Entity();
  virtual ~Entity();
  
  Entity(const Entity& from);
  
  inline Entity& operator=(const Entity& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const Entity& default_instance();
  
  void Swap(Entity* other);
  
  // implements Message ----------------------------------------------
  
  Entity* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const Entity& from);
  void MergeFrom(const Entity& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  
  // optional string entity_id = 2;
  inline bool has_entity_id() const;
  inline void clear_entity_id();
  static const int kEntityIdFieldNumber = 2;
  inline const ::std::string& entity_id() const;
  inline void set_entity_id(const ::std::string& value);
  inline void set_entity_id(const char* value);
  inline void set_entity_id(const char* value, size_t size);
  inline ::std::string* mutable_entity_id();
  inline ::std::string* release_entity_id();
  
  // optional string phone_number = 3;
  inline bool has_phone_number() const;
  inline void clear_phone_number();
  static const int kPhoneNumberFieldNumber = 3;
  inline const ::std::string& phone_number() const;
  inline void set_phone_number(const ::std::string& value);
  inline void set_phone_number(const char* value);
  inline void set_phone_number(const char* value, size_t size);
  inline ::std::string* mutable_phone_number();
  inline ::std::string* release_phone_number();
  
  // repeated string category = 4;
  inline int category_size() const;
  inline void clear_category();
  static const int kCategoryFieldNumber = 4;
  inline const ::std::string& category(int index) const;
  inline ::std::string* mutable_category(int index);
  inline void set_category(int index, const ::std::string& value);
  inline void set_category(int index, const char* value);
  inline void set_category(int index, const char* value, size_t size);
  inline ::std::string* add_category();
  inline void add_category(const ::std::string& value);
  inline void add_category(const char* value);
  inline void add_category(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& category() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_category();
  
  // optional .com.telenav.proto.Address display_address = 5;
  inline bool has_display_address() const;
  inline void clear_display_address();
  static const int kDisplayAddressFieldNumber = 5;
  inline const ::com::telenav::proto::Address& display_address() const;
  inline ::com::telenav::proto::Address* mutable_display_address();
  inline ::com::telenav::proto::Address* release_display_address();
  
  // optional .com.telenav.proto.LatLon rooftop_geocode = 6;
  inline bool has_rooftop_geocode() const;
  inline void clear_rooftop_geocode();
  static const int kRooftopGeocodeFieldNumber = 6;
  inline const ::com::telenav::proto::LatLon& rooftop_geocode() const;
  inline ::com::telenav::proto::LatLon* mutable_rooftop_geocode();
  inline ::com::telenav::proto::LatLon* release_rooftop_geocode();
  
  // repeated .com.telenav.proto.LatLon entrance_geocode = 7;
  inline int entrance_geocode_size() const;
  inline void clear_entrance_geocode();
  static const int kEntranceGeocodeFieldNumber = 7;
  inline const ::com::telenav::proto::LatLon& entrance_geocode(int index) const;
  inline ::com::telenav::proto::LatLon* mutable_entrance_geocode(int index);
  inline ::com::telenav::proto::LatLon* add_entrance_geocode();
  inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon >&
      entrance_geocode() const;
  inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon >*
      mutable_entrance_geocode();
  
  // optional string logo_url = 8;
  inline bool has_logo_url() const;
  inline void clear_logo_url();
  static const int kLogoUrlFieldNumber = 8;
  inline const ::std::string& logo_url() const;
  inline void set_logo_url(const ::std::string& value);
  inline void set_logo_url(const char* value);
  inline void set_logo_url(const char* value, size_t size);
  inline ::std::string* mutable_logo_url();
  inline ::std::string* release_logo_url();
  
  // optional string website = 9;
  inline bool has_website() const;
  inline void clear_website();
  static const int kWebsiteFieldNumber = 9;
  inline const ::std::string& website() const;
  inline void set_website(const ::std::string& value);
  inline void set_website(const char* value);
  inline void set_website(const char* value, size_t size);
  inline ::std::string* mutable_website();
  inline ::std::string* release_website();
  
  // optional string olson_timezone = 10;
  inline bool has_olson_timezone() const;
  inline void clear_olson_timezone();
  static const int kOlsonTimezoneFieldNumber = 10;
  inline const ::std::string& olson_timezone() const;
  inline void set_olson_timezone(const ::std::string& value);
  inline void set_olson_timezone(const char* value);
  inline void set_olson_timezone(const char* value, size_t size);
  inline ::std::string* mutable_olson_timezone();
  inline ::std::string* release_olson_timezone();
  
  // optional string email = 11;
  inline bool has_email() const;
  inline void clear_email();
  static const int kEmailFieldNumber = 11;
  inline const ::std::string& email() const;
  inline void set_email(const ::std::string& value);
  inline void set_email(const char* value);
  inline void set_email(const char* value, size_t size);
  inline ::std::string* mutable_email();
  inline ::std::string* release_email();
  
  // required .com.telenav.proto.EntityType entity_type = 99;
  inline bool has_entity_type() const;
  inline void clear_entity_type();
  static const int kEntityTypeFieldNumber = 99;
  inline com::telenav::proto::EntityType entity_type() const;
  inline void set_entity_type(com::telenav::proto::EntityType value);
  
  // optional string old_entity_id = 101;
  inline bool has_old_entity_id() const;
  inline void clear_old_entity_id();
  static const int kOldEntityIdFieldNumber = 101;
  inline const ::std::string& old_entity_id() const;
  inline void set_old_entity_id(const ::std::string& value);
  inline void set_old_entity_id(const char* value);
  inline void set_old_entity_id(const char* value, size_t size);
  inline ::std::string* mutable_old_entity_id();
  inline ::std::string* release_old_entity_id();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.Entity)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_entity_id();
  inline void clear_has_entity_id();
  inline void set_has_phone_number();
  inline void clear_has_phone_number();
  inline void set_has_display_address();
  inline void clear_has_display_address();
  inline void set_has_rooftop_geocode();
  inline void clear_has_rooftop_geocode();
  inline void set_has_logo_url();
  inline void clear_has_logo_url();
  inline void set_has_website();
  inline void clear_has_website();
  inline void set_has_olson_timezone();
  inline void clear_has_olson_timezone();
  inline void set_has_email();
  inline void clear_has_email();
  inline void set_has_entity_type();
  inline void clear_has_entity_type();
  inline void set_has_old_entity_id();
  inline void clear_has_old_entity_id();
  
  ::std::string* name_;
  ::std::string* entity_id_;
  ::std::string* phone_number_;
  ::google::protobuf::RepeatedPtrField< ::std::string> category_;
  ::com::telenav::proto::Address* display_address_;
  ::com::telenav::proto::LatLon* rooftop_geocode_;
  ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon > entrance_geocode_;
  ::std::string* logo_url_;
  ::std::string* website_;
  ::std::string* olson_timezone_;
  ::std::string* email_;
  ::std::string* old_entity_id_;
  int entity_type_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(13 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static Entity* default_instance_;
};
// -------------------------------------------------------------------

class EntityDetail : public ::google::protobuf::MessageLite {
 public:
  EntityDetail();
  virtual ~EntityDetail();
  
  EntityDetail(const EntityDetail& from);
  
  inline EntityDetail& operator=(const EntityDetail& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const EntityDetail& default_instance();
  
  void Swap(EntityDetail* other);
  
  // implements Message ----------------------------------------------
  
  EntityDetail* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EntityDetail& from);
  void MergeFrom(const EntityDetail& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .com.telenav.proto.Entity entity = 1;
  inline bool has_entity() const;
  inline void clear_entity();
  static const int kEntityFieldNumber = 1;
  inline const ::com::telenav::proto::Entity& entity() const;
  inline ::com::telenav::proto::Entity* mutable_entity();
  inline ::com::telenav::proto::Entity* release_entity();
  
  // repeated string availableFacet = 2;
  inline int availablefacet_size() const;
  inline void clear_availablefacet();
  static const int kAvailableFacetFieldNumber = 2;
  inline const ::std::string& availablefacet(int index) const;
  inline ::std::string* mutable_availablefacet(int index);
  inline void set_availablefacet(int index, const ::std::string& value);
  inline void set_availablefacet(int index, const char* value);
  inline void set_availablefacet(int index, const char* value, size_t size);
  inline ::std::string* add_availablefacet();
  inline void add_availablefacet(const ::std::string& value);
  inline void add_availablefacet(const char* value);
  inline void add_availablefacet(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& availablefacet() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_availablefacet();
  
  // repeated .com.telenav.proto.Facet facet = 3;
  inline int facet_size() const;
  inline void clear_facet();
  static const int kFacetFieldNumber = 3;
  inline const ::com::telenav::proto::Facet& facet(int index) const;
  inline ::com::telenav::proto::Facet* mutable_facet(int index);
  inline ::com::telenav::proto::Facet* add_facet();
  inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet >&
      facet() const;
  inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet >*
      mutable_facet();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.EntityDetail)
 private:
  inline void set_has_entity();
  inline void clear_has_entity();
  
  ::com::telenav::proto::Entity* entity_;
  ::google::protobuf::RepeatedPtrField< ::std::string> availablefacet_;
  ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet > facet_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static EntityDetail* default_instance_;
};
// -------------------------------------------------------------------

class EntityDetailRequest : public ::google::protobuf::MessageLite {
 public:
  EntityDetailRequest();
  virtual ~EntityDetailRequest();
  
  EntityDetailRequest(const EntityDetailRequest& from);
  
  inline EntityDetailRequest& operator=(const EntityDetailRequest& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const EntityDetailRequest& default_instance();
  
  void Swap(EntityDetailRequest* other);
  
  // implements Message ----------------------------------------------
  
  EntityDetailRequest* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EntityDetailRequest& from);
  void MergeFrom(const EntityDetailRequest& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string request_id = 1;
  inline bool has_request_id() const;
  inline void clear_request_id();
  static const int kRequestIdFieldNumber = 1;
  inline const ::std::string& request_id() const;
  inline void set_request_id(const ::std::string& value);
  inline void set_request_id(const char* value);
  inline void set_request_id(const char* value, size_t size);
  inline ::std::string* mutable_request_id();
  inline ::std::string* release_request_id();
  
  // required .com.telenav.proto.Context context = 2;
  inline bool has_context() const;
  inline void clear_context();
  static const int kContextFieldNumber = 2;
  inline const ::com::telenav::proto::Context& context() const;
  inline ::com::telenav::proto::Context* mutable_context();
  inline ::com::telenav::proto::Context* release_context();
  
  // repeated string entity_id = 10;
  inline int entity_id_size() const;
  inline void clear_entity_id();
  static const int kEntityIdFieldNumber = 10;
  inline const ::std::string& entity_id(int index) const;
  inline ::std::string* mutable_entity_id(int index);
  inline void set_entity_id(int index, const ::std::string& value);
  inline void set_entity_id(int index, const char* value);
  inline void set_entity_id(int index, const char* value, size_t size);
  inline ::std::string* add_entity_id();
  inline void add_entity_id(const ::std::string& value);
  inline void add_entity_id(const char* value);
  inline void add_entity_id(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& entity_id() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_entity_id();
  
  // repeated string facet = 11;
  inline int facet_size() const;
  inline void clear_facet();
  static const int kFacetFieldNumber = 11;
  inline const ::std::string& facet(int index) const;
  inline ::std::string* mutable_facet(int index);
  inline void set_facet(int index, const ::std::string& value);
  inline void set_facet(int index, const char* value);
  inline void set_facet(int index, const char* value, size_t size);
  inline ::std::string* add_facet();
  inline void add_facet(const ::std::string& value);
  inline void add_facet(const char* value);
  inline void add_facet(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& facet() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_facet();
  
  // optional string geo_source = 15;
  inline bool has_geo_source() const;
  inline void clear_geo_source();
  static const int kGeoSourceFieldNumber = 15;
  inline const ::std::string& geo_source() const;
  inline void set_geo_source(const ::std::string& value);
  inline void set_geo_source(const char* value);
  inline void set_geo_source(const char* value, size_t size);
  inline ::std::string* mutable_geo_source();
  inline ::std::string* release_geo_source();
  
  // optional string entity_source = 16;
  inline bool has_entity_source() const;
  inline void clear_entity_source();
  static const int kEntitySourceFieldNumber = 16;
  inline const ::std::string& entity_source() const;
  inline void set_entity_source(const ::std::string& value);
  inline void set_entity_source(const char* value);
  inline void set_entity_source(const char* value, size_t size);
  inline ::std::string* mutable_entity_source();
  inline ::std::string* release_entity_source();
  
  // repeated .com.telenav.proto.NameValuePair facet_params = 20;
  inline int facet_params_size() const;
  inline void clear_facet_params();
  static const int kFacetParamsFieldNumber = 20;
  inline const ::com::telenav::proto::NameValuePair& facet_params(int index) const;
  inline ::com::telenav::proto::NameValuePair* mutable_facet_params(int index);
  inline ::com::telenav::proto::NameValuePair* add_facet_params();
  inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::NameValuePair >&
      facet_params() const;
  inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::NameValuePair >*
      mutable_facet_params();
  
  // optional string lang = 30;
  inline bool has_lang() const;
  inline void clear_lang();
  static const int kLangFieldNumber = 30;
  inline const ::std::string& lang() const;
  inline void set_lang(const ::std::string& value);
  inline void set_lang(const char* value);
  inline void set_lang(const char* value, size_t size);
  inline ::std::string* mutable_lang();
  inline ::std::string* release_lang();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.EntityDetailRequest)
 private:
  inline void set_has_request_id();
  inline void clear_has_request_id();
  inline void set_has_context();
  inline void clear_has_context();
  inline void set_has_geo_source();
  inline void clear_has_geo_source();
  inline void set_has_entity_source();
  inline void clear_has_entity_source();
  inline void set_has_lang();
  inline void clear_has_lang();
  
  ::std::string* request_id_;
  ::com::telenav::proto::Context* context_;
  ::google::protobuf::RepeatedPtrField< ::std::string> entity_id_;
  ::google::protobuf::RepeatedPtrField< ::std::string> facet_;
  ::std::string* geo_source_;
  ::std::string* entity_source_;
  ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::NameValuePair > facet_params_;
  ::std::string* lang_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static EntityDetailRequest* default_instance_;
};
// -------------------------------------------------------------------

class EntityDetailResponse : public ::google::protobuf::MessageLite {
 public:
  EntityDetailResponse();
  virtual ~EntityDetailResponse();
  
  EntityDetailResponse(const EntityDetailResponse& from);
  
  inline EntityDetailResponse& operator=(const EntityDetailResponse& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const EntityDetailResponse& default_instance();
  
  void Swap(EntityDetailResponse* other);
  
  // implements Message ----------------------------------------------
  
  EntityDetailResponse* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EntityDetailResponse& from);
  void MergeFrom(const EntityDetailResponse& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .com.telenav.proto.ServiceStatus status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline const ::com::telenav::proto::ServiceStatus& status() const;
  inline ::com::telenav::proto::ServiceStatus* mutable_status();
  inline ::com::telenav::proto::ServiceStatus* release_status();
  
  // repeated .com.telenav.proto.EntityDetail entity_detail = 10;
  inline int entity_detail_size() const;
  inline void clear_entity_detail();
  static const int kEntityDetailFieldNumber = 10;
  inline const ::com::telenav::proto::EntityDetail& entity_detail(int index) const;
  inline ::com::telenav::proto::EntityDetail* mutable_entity_detail(int index);
  inline ::com::telenav::proto::EntityDetail* add_entity_detail();
  inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntityDetail >&
      entity_detail() const;
  inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntityDetail >*
      mutable_entity_detail();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.EntityDetailResponse)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  
  ::com::telenav::proto::ServiceStatus* status_;
  ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntityDetail > entity_detail_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static EntityDetailResponse* default_instance_;
};
// -------------------------------------------------------------------

class EntitySuggestionsRequest : public ::google::protobuf::MessageLite {
 public:
  EntitySuggestionsRequest();
  virtual ~EntitySuggestionsRequest();
  
  EntitySuggestionsRequest(const EntitySuggestionsRequest& from);
  
  inline EntitySuggestionsRequest& operator=(const EntitySuggestionsRequest& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const EntitySuggestionsRequest& default_instance();
  
  void Swap(EntitySuggestionsRequest* other);
  
  // implements Message ----------------------------------------------
  
  EntitySuggestionsRequest* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EntitySuggestionsRequest& from);
  void MergeFrom(const EntitySuggestionsRequest& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string request_id = 1;
  inline bool has_request_id() const;
  inline void clear_request_id();
  static const int kRequestIdFieldNumber = 1;
  inline const ::std::string& request_id() const;
  inline void set_request_id(const ::std::string& value);
  inline void set_request_id(const char* value);
  inline void set_request_id(const char* value, size_t size);
  inline ::std::string* mutable_request_id();
  inline ::std::string* release_request_id();
  
  // required .com.telenav.proto.Context context = 2;
  inline bool has_context() const;
  inline void clear_context();
  static const int kContextFieldNumber = 2;
  inline const ::com::telenav::proto::Context& context() const;
  inline ::com::telenav::proto::Context* mutable_context();
  inline ::com::telenav::proto::Context* release_context();
  
  // required string keyword = 10;
  inline bool has_keyword() const;
  inline void clear_keyword();
  static const int kKeywordFieldNumber = 10;
  inline const ::std::string& keyword() const;
  inline void set_keyword(const ::std::string& value);
  inline void set_keyword(const char* value);
  inline void set_keyword(const char* value, size_t size);
  inline ::std::string* mutable_keyword();
  inline ::std::string* release_keyword();
  
  // optional string current_location = 11;
  inline bool has_current_location() const;
  inline void clear_current_location();
  static const int kCurrentLocationFieldNumber = 11;
  inline const ::std::string& current_location() const;
  inline void set_current_location(const ::std::string& value);
  inline void set_current_location(const char* value);
  inline void set_current_location(const char* value, size_t size);
  inline ::std::string* mutable_current_location();
  inline ::std::string* release_current_location();
  
  // optional .com.telenav.proto.SuggestionsType type = 20 [default = ALL_SUGGESTIONS];
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 20;
  inline com::telenav::proto::SuggestionsType type() const;
  inline void set_type(com::telenav::proto::SuggestionsType value);
  
  // optional string geo_source = 30;
  inline bool has_geo_source() const;
  inline void clear_geo_source();
  static const int kGeoSourceFieldNumber = 30;
  inline const ::std::string& geo_source() const;
  inline void set_geo_source(const ::std::string& value);
  inline void set_geo_source(const char* value);
  inline void set_geo_source(const char* value, size_t size);
  inline ::std::string* mutable_geo_source();
  inline ::std::string* release_geo_source();
  
  // optional string entity_source = 31;
  inline bool has_entity_source() const;
  inline void clear_entity_source();
  static const int kEntitySourceFieldNumber = 31;
  inline const ::std::string& entity_source() const;
  inline void set_entity_source(const ::std::string& value);
  inline void set_entity_source(const char* value);
  inline void set_entity_source(const char* value, size_t size);
  inline ::std::string* mutable_entity_source();
  inline ::std::string* release_entity_source();
  
  // optional string lang = 50;
  inline bool has_lang() const;
  inline void clear_lang();
  static const int kLangFieldNumber = 50;
  inline const ::std::string& lang() const;
  inline void set_lang(const ::std::string& value);
  inline void set_lang(const char* value);
  inline void set_lang(const char* value, size_t size);
  inline ::std::string* mutable_lang();
  inline ::std::string* release_lang();
  
  // optional int32 limit = 100 [default = 10];
  inline bool has_limit() const;
  inline void clear_limit();
  static const int kLimitFieldNumber = 100;
  inline ::google::protobuf::int32 limit() const;
  inline void set_limit(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.EntitySuggestionsRequest)
 private:
  inline void set_has_request_id();
  inline void clear_has_request_id();
  inline void set_has_context();
  inline void clear_has_context();
  inline void set_has_keyword();
  inline void clear_has_keyword();
  inline void set_has_current_location();
  inline void clear_has_current_location();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_geo_source();
  inline void clear_has_geo_source();
  inline void set_has_entity_source();
  inline void clear_has_entity_source();
  inline void set_has_lang();
  inline void clear_has_lang();
  inline void set_has_limit();
  inline void clear_has_limit();
  
  ::std::string* request_id_;
  ::com::telenav::proto::Context* context_;
  ::std::string* keyword_;
  ::std::string* current_location_;
  ::std::string* geo_source_;
  ::std::string* entity_source_;
  int type_;
  ::google::protobuf::int32 limit_;
  ::std::string* lang_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static EntitySuggestionsRequest* default_instance_;
};
// -------------------------------------------------------------------

class EntitySuggestionsResponse : public ::google::protobuf::MessageLite {
 public:
  EntitySuggestionsResponse();
  virtual ~EntitySuggestionsResponse();
  
  EntitySuggestionsResponse(const EntitySuggestionsResponse& from);
  
  inline EntitySuggestionsResponse& operator=(const EntitySuggestionsResponse& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const EntitySuggestionsResponse& default_instance();
  
  void Swap(EntitySuggestionsResponse* other);
  
  // implements Message ----------------------------------------------
  
  EntitySuggestionsResponse* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EntitySuggestionsResponse& from);
  void MergeFrom(const EntitySuggestionsResponse& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .com.telenav.proto.ServiceStatus status = 1;
  inline bool has_status() const;
  inline void clear_status();
  static const int kStatusFieldNumber = 1;
  inline const ::com::telenav::proto::ServiceStatus& status() const;
  inline ::com::telenav::proto::ServiceStatus* mutable_status();
  inline ::com::telenav::proto::ServiceStatus* release_status();
  
  // repeated .com.telenav.proto.EntitySuggestionsResult result = 10;
  inline int result_size() const;
  inline void clear_result();
  static const int kResultFieldNumber = 10;
  inline const ::com::telenav::proto::EntitySuggestionsResult& result(int index) const;
  inline ::com::telenav::proto::EntitySuggestionsResult* mutable_result(int index);
  inline ::com::telenav::proto::EntitySuggestionsResult* add_result();
  inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntitySuggestionsResult >&
      result() const;
  inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntitySuggestionsResult >*
      mutable_result();
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.EntitySuggestionsResponse)
 private:
  inline void set_has_status();
  inline void clear_has_status();
  
  ::com::telenav::proto::ServiceStatus* status_;
  ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntitySuggestionsResult > result_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static EntitySuggestionsResponse* default_instance_;
};
// -------------------------------------------------------------------

class EntitySuggestionsResult : public ::google::protobuf::MessageLite {
 public:
  EntitySuggestionsResult();
  virtual ~EntitySuggestionsResult();
  
  EntitySuggestionsResult(const EntitySuggestionsResult& from);
  
  inline EntitySuggestionsResult& operator=(const EntitySuggestionsResult& from) {
    CopyFrom(from);
    return *this;
  }
  
  static const EntitySuggestionsResult& default_instance();
  
  void Swap(EntitySuggestionsResult* other);
  
  // implements Message ----------------------------------------------
  
  EntitySuggestionsResult* New() const;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
  void CopyFrom(const EntitySuggestionsResult& from);
  void MergeFrom(const EntitySuggestionsResult& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::std::string GetTypeName() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .com.telenav.proto.QuerySuggestion suggestion = 1;
  inline bool has_suggestion() const;
  inline void clear_suggestion();
  static const int kSuggestionFieldNumber = 1;
  inline const ::com::telenav::proto::QuerySuggestion& suggestion() const;
  inline ::com::telenav::proto::QuerySuggestion* mutable_suggestion();
  inline ::com::telenav::proto::QuerySuggestion* release_suggestion();
  
  // optional .com.telenav.proto.LatLon suggestion_location = 2;
  inline bool has_suggestion_location() const;
  inline void clear_suggestion_location();
  static const int kSuggestionLocationFieldNumber = 2;
  inline const ::com::telenav::proto::LatLon& suggestion_location() const;
  inline ::com::telenav::proto::LatLon* mutable_suggestion_location();
  inline ::com::telenav::proto::LatLon* release_suggestion_location();
  
  // optional double score = 10;
  inline bool has_score() const;
  inline void clear_score();
  static const int kScoreFieldNumber = 10;
  inline double score() const;
  inline void set_score(double value);
  
  // @@protoc_insertion_point(class_scope:com.telenav.proto.EntitySuggestionsResult)
 private:
  inline void set_has_suggestion();
  inline void clear_has_suggestion();
  inline void set_has_suggestion_location();
  inline void clear_has_suggestion_location();
  inline void set_has_score();
  inline void clear_has_score();
  
  ::com::telenav::proto::QuerySuggestion* suggestion_;
  ::com::telenav::proto::LatLon* suggestion_location_;
  double score_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_entity_2eproto();
  friend void protobuf_AssignDesc_entity_2eproto();
  friend void protobuf_ShutdownFile_entity_2eproto();
  
  void InitAsDefaultInstance();
  static EntitySuggestionsResult* default_instance_;
};
// ===================================================================


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

// EntitySearchRequest

// optional string request_id = 1;
inline bool EntitySearchRequest::has_request_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EntitySearchRequest::set_has_request_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EntitySearchRequest::clear_has_request_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EntitySearchRequest::clear_request_id() {
  if (request_id_ != &::google::protobuf::internal::kEmptyString) {
    request_id_->clear();
  }
  clear_has_request_id();
}
inline const ::std::string& EntitySearchRequest::request_id() const {
  return *request_id_;
}
inline void EntitySearchRequest::set_request_id(const ::std::string& value) {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  request_id_->assign(value);
}
inline void EntitySearchRequest::set_request_id(const char* value) {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  request_id_->assign(value);
}
inline void EntitySearchRequest::set_request_id(const char* value, size_t size) {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  request_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::mutable_request_id() {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  return request_id_;
}
inline ::std::string* EntitySearchRequest::release_request_id() {
  clear_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = request_id_;
    request_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required .com.telenav.proto.Context context = 2;
inline bool EntitySearchRequest::has_context() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EntitySearchRequest::set_has_context() {
  _has_bits_[0] |= 0x00000002u;
}
inline void EntitySearchRequest::clear_has_context() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void EntitySearchRequest::clear_context() {
  if (context_ != NULL) context_->::com::telenav::proto::Context::Clear();
  clear_has_context();
}
inline const ::com::telenav::proto::Context& EntitySearchRequest::context() const {
  return context_ != NULL ? *context_ : *default_instance_->context_;
}
inline ::com::telenav::proto::Context* EntitySearchRequest::mutable_context() {
  set_has_context();
  if (context_ == NULL) context_ = new ::com::telenav::proto::Context;
  return context_;
}
inline ::com::telenav::proto::Context* EntitySearchRequest::release_context() {
  clear_has_context();
  ::com::telenav::proto::Context* temp = context_;
  context_ = NULL;
  return temp;
}

// optional string query = 11;
inline bool EntitySearchRequest::has_query() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void EntitySearchRequest::set_has_query() {
  _has_bits_[0] |= 0x00000004u;
}
inline void EntitySearchRequest::clear_has_query() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void EntitySearchRequest::clear_query() {
  if (query_ != &::google::protobuf::internal::kEmptyString) {
    query_->clear();
  }
  clear_has_query();
}
inline const ::std::string& EntitySearchRequest::query() const {
  return *query_;
}
inline void EntitySearchRequest::set_query(const ::std::string& value) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  query_->assign(value);
}
inline void EntitySearchRequest::set_query(const char* value) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  query_->assign(value);
}
inline void EntitySearchRequest::set_query(const char* value, size_t size) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  query_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::mutable_query() {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  return query_;
}
inline ::std::string* EntitySearchRequest::release_query() {
  clear_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = query_;
    query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string current_location = 12;
inline bool EntitySearchRequest::has_current_location() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void EntitySearchRequest::set_has_current_location() {
  _has_bits_[0] |= 0x00000008u;
}
inline void EntitySearchRequest::clear_has_current_location() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void EntitySearchRequest::clear_current_location() {
  if (current_location_ != &::google::protobuf::internal::kEmptyString) {
    current_location_->clear();
  }
  clear_has_current_location();
}
inline const ::std::string& EntitySearchRequest::current_location() const {
  return *current_location_;
}
inline void EntitySearchRequest::set_current_location(const ::std::string& value) {
  set_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    current_location_ = new ::std::string;
  }
  current_location_->assign(value);
}
inline void EntitySearchRequest::set_current_location(const char* value) {
  set_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    current_location_ = new ::std::string;
  }
  current_location_->assign(value);
}
inline void EntitySearchRequest::set_current_location(const char* value, size_t size) {
  set_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    current_location_ = new ::std::string;
  }
  current_location_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::mutable_current_location() {
  set_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    current_location_ = new ::std::string;
  }
  return current_location_;
}
inline ::std::string* EntitySearchRequest::release_current_location() {
  clear_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = current_location_;
    current_location_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated .com.telenav.proto.LatLon route_point = 13;
inline int EntitySearchRequest::route_point_size() const {
  return route_point_.size();
}
inline void EntitySearchRequest::clear_route_point() {
  route_point_.Clear();
}
inline const ::com::telenav::proto::LatLon& EntitySearchRequest::route_point(int index) const {
  return route_point_.Get(index);
}
inline ::com::telenav::proto::LatLon* EntitySearchRequest::mutable_route_point(int index) {
  return route_point_.Mutable(index);
}
inline ::com::telenav::proto::LatLon* EntitySearchRequest::add_route_point() {
  return route_point_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon >&
EntitySearchRequest::route_point() const {
  return route_point_;
}
inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon >*
EntitySearchRequest::mutable_route_point() {
  return &route_point_;
}

// repeated string category = 21;
inline int EntitySearchRequest::category_size() const {
  return category_.size();
}
inline void EntitySearchRequest::clear_category() {
  category_.Clear();
}
inline const ::std::string& EntitySearchRequest::category(int index) const {
  return category_.Get(index);
}
inline ::std::string* EntitySearchRequest::mutable_category(int index) {
  return category_.Mutable(index);
}
inline void EntitySearchRequest::set_category(int index, const ::std::string& value) {
  category_.Mutable(index)->assign(value);
}
inline void EntitySearchRequest::set_category(int index, const char* value) {
  category_.Mutable(index)->assign(value);
}
inline void EntitySearchRequest::set_category(int index, const char* value, size_t size) {
  category_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::add_category() {
  return category_.Add();
}
inline void EntitySearchRequest::add_category(const ::std::string& value) {
  category_.Add()->assign(value);
}
inline void EntitySearchRequest::add_category(const char* value) {
  category_.Add()->assign(value);
}
inline void EntitySearchRequest::add_category(const char* value, size_t size) {
  category_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
EntitySearchRequest::category() const {
  return category_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
EntitySearchRequest::mutable_category() {
  return &category_;
}

// optional string entity_source = 30;
inline bool EntitySearchRequest::has_entity_source() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void EntitySearchRequest::set_has_entity_source() {
  _has_bits_[0] |= 0x00000040u;
}
inline void EntitySearchRequest::clear_has_entity_source() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void EntitySearchRequest::clear_entity_source() {
  if (entity_source_ != &::google::protobuf::internal::kEmptyString) {
    entity_source_->clear();
  }
  clear_has_entity_source();
}
inline const ::std::string& EntitySearchRequest::entity_source() const {
  return *entity_source_;
}
inline void EntitySearchRequest::set_entity_source(const ::std::string& value) {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  entity_source_->assign(value);
}
inline void EntitySearchRequest::set_entity_source(const char* value) {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  entity_source_->assign(value);
}
inline void EntitySearchRequest::set_entity_source(const char* value, size_t size) {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  entity_source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::mutable_entity_source() {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  return entity_source_;
}
inline ::std::string* EntitySearchRequest::release_entity_source() {
  clear_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = entity_source_;
    entity_source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string geo_source = 31;
inline bool EntitySearchRequest::has_geo_source() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void EntitySearchRequest::set_has_geo_source() {
  _has_bits_[0] |= 0x00000080u;
}
inline void EntitySearchRequest::clear_has_geo_source() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void EntitySearchRequest::clear_geo_source() {
  if (geo_source_ != &::google::protobuf::internal::kEmptyString) {
    geo_source_->clear();
  }
  clear_has_geo_source();
}
inline const ::std::string& EntitySearchRequest::geo_source() const {
  return *geo_source_;
}
inline void EntitySearchRequest::set_geo_source(const ::std::string& value) {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  geo_source_->assign(value);
}
inline void EntitySearchRequest::set_geo_source(const char* value) {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  geo_source_->assign(value);
}
inline void EntitySearchRequest::set_geo_source(const char* value, size_t size) {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  geo_source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::mutable_geo_source() {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  return geo_source_;
}
inline ::std::string* EntitySearchRequest::release_geo_source() {
  clear_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = geo_source_;
    geo_source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 offset = 100;
inline bool EntitySearchRequest::has_offset() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void EntitySearchRequest::set_has_offset() {
  _has_bits_[0] |= 0x00000100u;
}
inline void EntitySearchRequest::clear_has_offset() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void EntitySearchRequest::clear_offset() {
  offset_ = 0;
  clear_has_offset();
}
inline ::google::protobuf::int32 EntitySearchRequest::offset() const {
  return offset_;
}
inline void EntitySearchRequest::set_offset(::google::protobuf::int32 value) {
  set_has_offset();
  offset_ = value;
}

// optional int32 limit = 101;
inline bool EntitySearchRequest::has_limit() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void EntitySearchRequest::set_has_limit() {
  _has_bits_[0] |= 0x00000200u;
}
inline void EntitySearchRequest::clear_has_limit() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void EntitySearchRequest::clear_limit() {
  limit_ = 0;
  clear_has_limit();
}
inline ::google::protobuf::int32 EntitySearchRequest::limit() const {
  return limit_;
}
inline void EntitySearchRequest::set_limit(::google::protobuf::int32 value) {
  set_has_limit();
  limit_ = value;
}

// optional string rank_by = 102;
inline bool EntitySearchRequest::has_rank_by() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void EntitySearchRequest::set_has_rank_by() {
  _has_bits_[0] |= 0x00000400u;
}
inline void EntitySearchRequest::clear_has_rank_by() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void EntitySearchRequest::clear_rank_by() {
  if (rank_by_ != &::google::protobuf::internal::kEmptyString) {
    rank_by_->clear();
  }
  clear_has_rank_by();
}
inline const ::std::string& EntitySearchRequest::rank_by() const {
  return *rank_by_;
}
inline void EntitySearchRequest::set_rank_by(const ::std::string& value) {
  set_has_rank_by();
  if (rank_by_ == &::google::protobuf::internal::kEmptyString) {
    rank_by_ = new ::std::string;
  }
  rank_by_->assign(value);
}
inline void EntitySearchRequest::set_rank_by(const char* value) {
  set_has_rank_by();
  if (rank_by_ == &::google::protobuf::internal::kEmptyString) {
    rank_by_ = new ::std::string;
  }
  rank_by_->assign(value);
}
inline void EntitySearchRequest::set_rank_by(const char* value, size_t size) {
  set_has_rank_by();
  if (rank_by_ == &::google::protobuf::internal::kEmptyString) {
    rank_by_ = new ::std::string;
  }
  rank_by_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::mutable_rank_by() {
  set_has_rank_by();
  if (rank_by_ == &::google::protobuf::internal::kEmptyString) {
    rank_by_ = new ::std::string;
  }
  return rank_by_;
}
inline ::std::string* EntitySearchRequest::release_rank_by() {
  clear_has_rank_by();
  if (rank_by_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = rank_by_;
    rank_by_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string lang = 120;
inline bool EntitySearchRequest::has_lang() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void EntitySearchRequest::set_has_lang() {
  _has_bits_[0] |= 0x00000800u;
}
inline void EntitySearchRequest::clear_has_lang() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void EntitySearchRequest::clear_lang() {
  if (lang_ != &::google::protobuf::internal::kEmptyString) {
    lang_->clear();
  }
  clear_has_lang();
}
inline const ::std::string& EntitySearchRequest::lang() const {
  return *lang_;
}
inline void EntitySearchRequest::set_lang(const ::std::string& value) {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  lang_->assign(value);
}
inline void EntitySearchRequest::set_lang(const char* value) {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  lang_->assign(value);
}
inline void EntitySearchRequest::set_lang(const char* value, size_t size) {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  lang_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::mutable_lang() {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  return lang_;
}
inline ::std::string* EntitySearchRequest::release_lang() {
  clear_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = lang_;
    lang_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string country = 121;
inline bool EntitySearchRequest::has_country() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void EntitySearchRequest::set_has_country() {
  _has_bits_[0] |= 0x00001000u;
}
inline void EntitySearchRequest::clear_has_country() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void EntitySearchRequest::clear_country() {
  if (country_ != &::google::protobuf::internal::kEmptyString) {
    country_->clear();
  }
  clear_has_country();
}
inline const ::std::string& EntitySearchRequest::country() const {
  return *country_;
}
inline void EntitySearchRequest::set_country(const ::std::string& value) {
  set_has_country();
  if (country_ == &::google::protobuf::internal::kEmptyString) {
    country_ = new ::std::string;
  }
  country_->assign(value);
}
inline void EntitySearchRequest::set_country(const char* value) {
  set_has_country();
  if (country_ == &::google::protobuf::internal::kEmptyString) {
    country_ = new ::std::string;
  }
  country_->assign(value);
}
inline void EntitySearchRequest::set_country(const char* value, size_t size) {
  set_has_country();
  if (country_ == &::google::protobuf::internal::kEmptyString) {
    country_ = new ::std::string;
  }
  country_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::mutable_country() {
  set_has_country();
  if (country_ == &::google::protobuf::internal::kEmptyString) {
    country_ = new ::std::string;
  }
  return country_;
}
inline ::std::string* EntitySearchRequest::release_country() {
  clear_has_country();
  if (country_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = country_;
    country_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string search_context = 150;
inline bool EntitySearchRequest::has_search_context() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void EntitySearchRequest::set_has_search_context() {
  _has_bits_[0] |= 0x00002000u;
}
inline void EntitySearchRequest::clear_has_search_context() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void EntitySearchRequest::clear_search_context() {
  if (search_context_ != &::google::protobuf::internal::kEmptyString) {
    search_context_->clear();
  }
  clear_has_search_context();
}
inline const ::std::string& EntitySearchRequest::search_context() const {
  return *search_context_;
}
inline void EntitySearchRequest::set_search_context(const ::std::string& value) {
  set_has_search_context();
  if (search_context_ == &::google::protobuf::internal::kEmptyString) {
    search_context_ = new ::std::string;
  }
  search_context_->assign(value);
}
inline void EntitySearchRequest::set_search_context(const char* value) {
  set_has_search_context();
  if (search_context_ == &::google::protobuf::internal::kEmptyString) {
    search_context_ = new ::std::string;
  }
  search_context_->assign(value);
}
inline void EntitySearchRequest::set_search_context(const char* value, size_t size) {
  set_has_search_context();
  if (search_context_ == &::google::protobuf::internal::kEmptyString) {
    search_context_ = new ::std::string;
  }
  search_context_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySearchRequest::mutable_search_context() {
  set_has_search_context();
  if (search_context_ == &::google::protobuf::internal::kEmptyString) {
    search_context_ = new ::std::string;
  }
  return search_context_;
}
inline ::std::string* EntitySearchRequest::release_search_context() {
  clear_has_search_context();
  if (search_context_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = search_context_;
    search_context_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// EntitySearchResponse

// optional .com.telenav.proto.ServiceStatus status = 1;
inline bool EntitySearchResponse::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EntitySearchResponse::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EntitySearchResponse::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EntitySearchResponse::clear_status() {
  if (status_ != NULL) status_->::com::telenav::proto::ServiceStatus::Clear();
  clear_has_status();
}
inline const ::com::telenav::proto::ServiceStatus& EntitySearchResponse::status() const {
  return status_ != NULL ? *status_ : *default_instance_->status_;
}
inline ::com::telenav::proto::ServiceStatus* EntitySearchResponse::mutable_status() {
  set_has_status();
  if (status_ == NULL) status_ = new ::com::telenav::proto::ServiceStatus;
  return status_;
}
inline ::com::telenav::proto::ServiceStatus* EntitySearchResponse::release_status() {
  clear_has_status();
  ::com::telenav::proto::ServiceStatus* temp = status_;
  status_ = NULL;
  return temp;
}

// optional .com.telenav.proto.EntitySearchSubStatus sub_status = 2;
inline bool EntitySearchResponse::has_sub_status() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EntitySearchResponse::set_has_sub_status() {
  _has_bits_[0] |= 0x00000002u;
}
inline void EntitySearchResponse::clear_has_sub_status() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void EntitySearchResponse::clear_sub_status() {
  sub_status_ = 12220;
  clear_has_sub_status();
}
inline com::telenav::proto::EntitySearchSubStatus EntitySearchResponse::sub_status() const {
  return static_cast< com::telenav::proto::EntitySearchSubStatus >(sub_status_);
}
inline void EntitySearchResponse::set_sub_status(com::telenav::proto::EntitySearchSubStatus value) {
  GOOGLE_DCHECK(com::telenav::proto::EntitySearchSubStatus_IsValid(value));
  set_has_sub_status();
  sub_status_ = value;
}

// optional .com.telenav.proto.SearchContext search_context = 9;
inline bool EntitySearchResponse::has_search_context() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void EntitySearchResponse::set_has_search_context() {
  _has_bits_[0] |= 0x00000004u;
}
inline void EntitySearchResponse::clear_has_search_context() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void EntitySearchResponse::clear_search_context() {
  if (search_context_ != NULL) search_context_->::com::telenav::proto::SearchContext::Clear();
  clear_has_search_context();
}
inline const ::com::telenav::proto::SearchContext& EntitySearchResponse::search_context() const {
  return search_context_ != NULL ? *search_context_ : *default_instance_->search_context_;
}
inline ::com::telenav::proto::SearchContext* EntitySearchResponse::mutable_search_context() {
  set_has_search_context();
  if (search_context_ == NULL) search_context_ = new ::com::telenav::proto::SearchContext;
  return search_context_;
}
inline ::com::telenav::proto::SearchContext* EntitySearchResponse::release_search_context() {
  clear_has_search_context();
  ::com::telenav::proto::SearchContext* temp = search_context_;
  search_context_ = NULL;
  return temp;
}

// optional .com.telenav.proto.QueryResolution query_resolution = 10;
inline bool EntitySearchResponse::has_query_resolution() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void EntitySearchResponse::set_has_query_resolution() {
  _has_bits_[0] |= 0x00000008u;
}
inline void EntitySearchResponse::clear_has_query_resolution() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void EntitySearchResponse::clear_query_resolution() {
  if (query_resolution_ != NULL) query_resolution_->::com::telenav::proto::QueryResolution::Clear();
  clear_has_query_resolution();
}
inline const ::com::telenav::proto::QueryResolution& EntitySearchResponse::query_resolution() const {
  return query_resolution_ != NULL ? *query_resolution_ : *default_instance_->query_resolution_;
}
inline ::com::telenav::proto::QueryResolution* EntitySearchResponse::mutable_query_resolution() {
  set_has_query_resolution();
  if (query_resolution_ == NULL) query_resolution_ = new ::com::telenav::proto::QueryResolution;
  return query_resolution_;
}
inline ::com::telenav::proto::QueryResolution* EntitySearchResponse::release_query_resolution() {
  clear_has_query_resolution();
  ::com::telenav::proto::QueryResolution* temp = query_resolution_;
  query_resolution_ = NULL;
  return temp;
}

// optional int32 total_results = 20;
inline bool EntitySearchResponse::has_total_results() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void EntitySearchResponse::set_has_total_results() {
  _has_bits_[0] |= 0x00000010u;
}
inline void EntitySearchResponse::clear_has_total_results() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void EntitySearchResponse::clear_total_results() {
  total_results_ = 0;
  clear_has_total_results();
}
inline ::google::protobuf::int32 EntitySearchResponse::total_results() const {
  return total_results_;
}
inline void EntitySearchResponse::set_total_results(::google::protobuf::int32 value) {
  set_has_total_results();
  total_results_ = value;
}

// repeated .com.telenav.proto.SearchResult result = 30;
inline int EntitySearchResponse::result_size() const {
  return result_.size();
}
inline void EntitySearchResponse::clear_result() {
  result_.Clear();
}
inline const ::com::telenav::proto::SearchResult& EntitySearchResponse::result(int index) const {
  return result_.Get(index);
}
inline ::com::telenav::proto::SearchResult* EntitySearchResponse::mutable_result(int index) {
  return result_.Mutable(index);
}
inline ::com::telenav::proto::SearchResult* EntitySearchResponse::add_result() {
  return result_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::SearchResult >&
EntitySearchResponse::result() const {
  return result_;
}
inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::SearchResult >*
EntitySearchResponse::mutable_result() {
  return &result_;
}

// repeated .com.telenav.proto.QuerySuggestion suggestion = 50;
inline int EntitySearchResponse::suggestion_size() const {
  return suggestion_.size();
}
inline void EntitySearchResponse::clear_suggestion() {
  suggestion_.Clear();
}
inline const ::com::telenav::proto::QuerySuggestion& EntitySearchResponse::suggestion(int index) const {
  return suggestion_.Get(index);
}
inline ::com::telenav::proto::QuerySuggestion* EntitySearchResponse::mutable_suggestion(int index) {
  return suggestion_.Mutable(index);
}
inline ::com::telenav::proto::QuerySuggestion* EntitySearchResponse::add_suggestion() {
  return suggestion_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::QuerySuggestion >&
EntitySearchResponse::suggestion() const {
  return suggestion_;
}
inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::QuerySuggestion >*
EntitySearchResponse::mutable_suggestion() {
  return &suggestion_;
}

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

// SearchContext

// optional string previous = 1;
inline bool SearchContext::has_previous() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SearchContext::set_has_previous() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SearchContext::clear_has_previous() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SearchContext::clear_previous() {
  if (previous_ != &::google::protobuf::internal::kEmptyString) {
    previous_->clear();
  }
  clear_has_previous();
}
inline const ::std::string& SearchContext::previous() const {
  return *previous_;
}
inline void SearchContext::set_previous(const ::std::string& value) {
  set_has_previous();
  if (previous_ == &::google::protobuf::internal::kEmptyString) {
    previous_ = new ::std::string;
  }
  previous_->assign(value);
}
inline void SearchContext::set_previous(const char* value) {
  set_has_previous();
  if (previous_ == &::google::protobuf::internal::kEmptyString) {
    previous_ = new ::std::string;
  }
  previous_->assign(value);
}
inline void SearchContext::set_previous(const char* value, size_t size) {
  set_has_previous();
  if (previous_ == &::google::protobuf::internal::kEmptyString) {
    previous_ = new ::std::string;
  }
  previous_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SearchContext::mutable_previous() {
  set_has_previous();
  if (previous_ == &::google::protobuf::internal::kEmptyString) {
    previous_ = new ::std::string;
  }
  return previous_;
}
inline ::std::string* SearchContext::release_previous() {
  clear_has_previous();
  if (previous_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = previous_;
    previous_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string next = 2;
inline bool SearchContext::has_next() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SearchContext::set_has_next() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SearchContext::clear_has_next() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SearchContext::clear_next() {
  if (next_ != &::google::protobuf::internal::kEmptyString) {
    next_->clear();
  }
  clear_has_next();
}
inline const ::std::string& SearchContext::next() const {
  return *next_;
}
inline void SearchContext::set_next(const ::std::string& value) {
  set_has_next();
  if (next_ == &::google::protobuf::internal::kEmptyString) {
    next_ = new ::std::string;
  }
  next_->assign(value);
}
inline void SearchContext::set_next(const char* value) {
  set_has_next();
  if (next_ == &::google::protobuf::internal::kEmptyString) {
    next_ = new ::std::string;
  }
  next_->assign(value);
}
inline void SearchContext::set_next(const char* value, size_t size) {
  set_has_next();
  if (next_ == &::google::protobuf::internal::kEmptyString) {
    next_ = new ::std::string;
  }
  next_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SearchContext::mutable_next() {
  set_has_next();
  if (next_ == &::google::protobuf::internal::kEmptyString) {
    next_ = new ::std::string;
  }
  return next_;
}
inline ::std::string* SearchContext::release_next() {
  clear_has_next();
  if (next_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = next_;
    next_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// QueryResolution

// optional string query_type = 1;
inline bool QueryResolution::has_query_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void QueryResolution::set_has_query_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void QueryResolution::clear_has_query_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void QueryResolution::clear_query_type() {
  if (query_type_ != &::google::protobuf::internal::kEmptyString) {
    query_type_->clear();
  }
  clear_has_query_type();
}
inline const ::std::string& QueryResolution::query_type() const {
  return *query_type_;
}
inline void QueryResolution::set_query_type(const ::std::string& value) {
  set_has_query_type();
  if (query_type_ == &::google::protobuf::internal::kEmptyString) {
    query_type_ = new ::std::string;
  }
  query_type_->assign(value);
}
inline void QueryResolution::set_query_type(const char* value) {
  set_has_query_type();
  if (query_type_ == &::google::protobuf::internal::kEmptyString) {
    query_type_ = new ::std::string;
  }
  query_type_->assign(value);
}
inline void QueryResolution::set_query_type(const char* value, size_t size) {
  set_has_query_type();
  if (query_type_ == &::google::protobuf::internal::kEmptyString) {
    query_type_ = new ::std::string;
  }
  query_type_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* QueryResolution::mutable_query_type() {
  set_has_query_type();
  if (query_type_ == &::google::protobuf::internal::kEmptyString) {
    query_type_ = new ::std::string;
  }
  return query_type_;
}
inline ::std::string* QueryResolution::release_query_type() {
  clear_has_query_type();
  if (query_type_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = query_type_;
    query_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string what = 2;
inline bool QueryResolution::has_what() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void QueryResolution::set_has_what() {
  _has_bits_[0] |= 0x00000002u;
}
inline void QueryResolution::clear_has_what() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void QueryResolution::clear_what() {
  if (what_ != &::google::protobuf::internal::kEmptyString) {
    what_->clear();
  }
  clear_has_what();
}
inline const ::std::string& QueryResolution::what() const {
  return *what_;
}
inline void QueryResolution::set_what(const ::std::string& value) {
  set_has_what();
  if (what_ == &::google::protobuf::internal::kEmptyString) {
    what_ = new ::std::string;
  }
  what_->assign(value);
}
inline void QueryResolution::set_what(const char* value) {
  set_has_what();
  if (what_ == &::google::protobuf::internal::kEmptyString) {
    what_ = new ::std::string;
  }
  what_->assign(value);
}
inline void QueryResolution::set_what(const char* value, size_t size) {
  set_has_what();
  if (what_ == &::google::protobuf::internal::kEmptyString) {
    what_ = new ::std::string;
  }
  what_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* QueryResolution::mutable_what() {
  set_has_what();
  if (what_ == &::google::protobuf::internal::kEmptyString) {
    what_ = new ::std::string;
  }
  return what_;
}
inline ::std::string* QueryResolution::release_what() {
  clear_has_what();
  if (what_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = what_;
    what_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string where = 3;
inline bool QueryResolution::has_where() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void QueryResolution::set_has_where() {
  _has_bits_[0] |= 0x00000004u;
}
inline void QueryResolution::clear_has_where() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void QueryResolution::clear_where() {
  if (where_ != &::google::protobuf::internal::kEmptyString) {
    where_->clear();
  }
  clear_has_where();
}
inline const ::std::string& QueryResolution::where() const {
  return *where_;
}
inline void QueryResolution::set_where(const ::std::string& value) {
  set_has_where();
  if (where_ == &::google::protobuf::internal::kEmptyString) {
    where_ = new ::std::string;
  }
  where_->assign(value);
}
inline void QueryResolution::set_where(const char* value) {
  set_has_where();
  if (where_ == &::google::protobuf::internal::kEmptyString) {
    where_ = new ::std::string;
  }
  where_->assign(value);
}
inline void QueryResolution::set_where(const char* value, size_t size) {
  set_has_where();
  if (where_ == &::google::protobuf::internal::kEmptyString) {
    where_ = new ::std::string;
  }
  where_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* QueryResolution::mutable_where() {
  set_has_where();
  if (where_ == &::google::protobuf::internal::kEmptyString) {
    where_ = new ::std::string;
  }
  return where_;
}
inline ::std::string* QueryResolution::release_where() {
  clear_has_where();
  if (where_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = where_;
    where_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated string category = 5;
inline int QueryResolution::category_size() const {
  return category_.size();
}
inline void QueryResolution::clear_category() {
  category_.Clear();
}
inline const ::std::string& QueryResolution::category(int index) const {
  return category_.Get(index);
}
inline ::std::string* QueryResolution::mutable_category(int index) {
  return category_.Mutable(index);
}
inline void QueryResolution::set_category(int index, const ::std::string& value) {
  category_.Mutable(index)->assign(value);
}
inline void QueryResolution::set_category(int index, const char* value) {
  category_.Mutable(index)->assign(value);
}
inline void QueryResolution::set_category(int index, const char* value, size_t size) {
  category_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* QueryResolution::add_category() {
  return category_.Add();
}
inline void QueryResolution::add_category(const ::std::string& value) {
  category_.Add()->assign(value);
}
inline void QueryResolution::add_category(const char* value) {
  category_.Add()->assign(value);
}
inline void QueryResolution::add_category(const char* value, size_t size) {
  category_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
QueryResolution::category() const {
  return category_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
QueryResolution::mutable_category() {
  return &category_;
}

// optional string rewritten_query = 10;
inline bool QueryResolution::has_rewritten_query() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void QueryResolution::set_has_rewritten_query() {
  _has_bits_[0] |= 0x00000010u;
}
inline void QueryResolution::clear_has_rewritten_query() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void QueryResolution::clear_rewritten_query() {
  if (rewritten_query_ != &::google::protobuf::internal::kEmptyString) {
    rewritten_query_->clear();
  }
  clear_has_rewritten_query();
}
inline const ::std::string& QueryResolution::rewritten_query() const {
  return *rewritten_query_;
}
inline void QueryResolution::set_rewritten_query(const ::std::string& value) {
  set_has_rewritten_query();
  if (rewritten_query_ == &::google::protobuf::internal::kEmptyString) {
    rewritten_query_ = new ::std::string;
  }
  rewritten_query_->assign(value);
}
inline void QueryResolution::set_rewritten_query(const char* value) {
  set_has_rewritten_query();
  if (rewritten_query_ == &::google::protobuf::internal::kEmptyString) {
    rewritten_query_ = new ::std::string;
  }
  rewritten_query_->assign(value);
}
inline void QueryResolution::set_rewritten_query(const char* value, size_t size) {
  set_has_rewritten_query();
  if (rewritten_query_ == &::google::protobuf::internal::kEmptyString) {
    rewritten_query_ = new ::std::string;
  }
  rewritten_query_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* QueryResolution::mutable_rewritten_query() {
  set_has_rewritten_query();
  if (rewritten_query_ == &::google::protobuf::internal::kEmptyString) {
    rewritten_query_ = new ::std::string;
  }
  return rewritten_query_;
}
inline ::std::string* QueryResolution::release_rewritten_query() {
  clear_has_rewritten_query();
  if (rewritten_query_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = rewritten_query_;
    rewritten_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional .com.telenav.proto.LatLon center_geocode = 20;
inline bool QueryResolution::has_center_geocode() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void QueryResolution::set_has_center_geocode() {
  _has_bits_[0] |= 0x00000020u;
}
inline void QueryResolution::clear_has_center_geocode() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void QueryResolution::clear_center_geocode() {
  if (center_geocode_ != NULL) center_geocode_->::com::telenav::proto::LatLon::Clear();
  clear_has_center_geocode();
}
inline const ::com::telenav::proto::LatLon& QueryResolution::center_geocode() const {
  return center_geocode_ != NULL ? *center_geocode_ : *default_instance_->center_geocode_;
}
inline ::com::telenav::proto::LatLon* QueryResolution::mutable_center_geocode() {
  set_has_center_geocode();
  if (center_geocode_ == NULL) center_geocode_ = new ::com::telenav::proto::LatLon;
  return center_geocode_;
}
inline ::com::telenav::proto::LatLon* QueryResolution::release_center_geocode() {
  clear_has_center_geocode();
  ::com::telenav::proto::LatLon* temp = center_geocode_;
  center_geocode_ = NULL;
  return temp;
}

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

// QuerySuggestion

// optional string display_label = 1;
inline bool QuerySuggestion::has_display_label() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void QuerySuggestion::set_has_display_label() {
  _has_bits_[0] |= 0x00000001u;
}
inline void QuerySuggestion::clear_has_display_label() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void QuerySuggestion::clear_display_label() {
  if (display_label_ != &::google::protobuf::internal::kEmptyString) {
    display_label_->clear();
  }
  clear_has_display_label();
}
inline const ::std::string& QuerySuggestion::display_label() const {
  return *display_label_;
}
inline void QuerySuggestion::set_display_label(const ::std::string& value) {
  set_has_display_label();
  if (display_label_ == &::google::protobuf::internal::kEmptyString) {
    display_label_ = new ::std::string;
  }
  display_label_->assign(value);
}
inline void QuerySuggestion::set_display_label(const char* value) {
  set_has_display_label();
  if (display_label_ == &::google::protobuf::internal::kEmptyString) {
    display_label_ = new ::std::string;
  }
  display_label_->assign(value);
}
inline void QuerySuggestion::set_display_label(const char* value, size_t size) {
  set_has_display_label();
  if (display_label_ == &::google::protobuf::internal::kEmptyString) {
    display_label_ = new ::std::string;
  }
  display_label_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* QuerySuggestion::mutable_display_label() {
  set_has_display_label();
  if (display_label_ == &::google::protobuf::internal::kEmptyString) {
    display_label_ = new ::std::string;
  }
  return display_label_;
}
inline ::std::string* QuerySuggestion::release_display_label() {
  clear_has_display_label();
  if (display_label_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = display_label_;
    display_label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string query = 2;
inline bool QuerySuggestion::has_query() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void QuerySuggestion::set_has_query() {
  _has_bits_[0] |= 0x00000002u;
}
inline void QuerySuggestion::clear_has_query() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void QuerySuggestion::clear_query() {
  if (query_ != &::google::protobuf::internal::kEmptyString) {
    query_->clear();
  }
  clear_has_query();
}
inline const ::std::string& QuerySuggestion::query() const {
  return *query_;
}
inline void QuerySuggestion::set_query(const ::std::string& value) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  query_->assign(value);
}
inline void QuerySuggestion::set_query(const char* value) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  query_->assign(value);
}
inline void QuerySuggestion::set_query(const char* value, size_t size) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  query_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* QuerySuggestion::mutable_query() {
  set_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    query_ = new ::std::string;
  }
  return query_;
}
inline ::std::string* QuerySuggestion::release_query() {
  clear_has_query();
  if (query_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = query_;
    query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// SearchResult

// required .com.telenav.proto.Entity entity = 1;
inline bool SearchResult::has_entity() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SearchResult::set_has_entity() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SearchResult::clear_has_entity() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SearchResult::clear_entity() {
  if (entity_ != NULL) entity_->::com::telenav::proto::Entity::Clear();
  clear_has_entity();
}
inline const ::com::telenav::proto::Entity& SearchResult::entity() const {
  return entity_ != NULL ? *entity_ : *default_instance_->entity_;
}
inline ::com::telenav::proto::Entity* SearchResult::mutable_entity() {
  set_has_entity();
  if (entity_ == NULL) entity_ = new ::com::telenav::proto::Entity;
  return entity_;
}
inline ::com::telenav::proto::Entity* SearchResult::release_entity() {
  clear_has_entity();
  ::com::telenav::proto::Entity* temp = entity_;
  entity_ = NULL;
  return temp;
}

// optional double score = 10;
inline bool SearchResult::has_score() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SearchResult::set_has_score() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SearchResult::clear_has_score() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SearchResult::clear_score() {
  score_ = 0;
  clear_has_score();
}
inline double SearchResult::score() const {
  return score_;
}
inline void SearchResult::set_score(double value) {
  set_has_score();
  score_ = value;
}

// optional int32 distance = 11;
inline bool SearchResult::has_distance() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SearchResult::set_has_distance() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SearchResult::clear_has_distance() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SearchResult::clear_distance() {
  distance_ = 0;
  clear_has_distance();
}
inline ::google::protobuf::int32 SearchResult::distance() const {
  return distance_;
}
inline void SearchResult::set_distance(::google::protobuf::int32 value) {
  set_has_distance();
  distance_ = value;
}

// repeated .com.telenav.proto.Facet facet = 20;
inline int SearchResult::facet_size() const {
  return facet_.size();
}
inline void SearchResult::clear_facet() {
  facet_.Clear();
}
inline const ::com::telenav::proto::Facet& SearchResult::facet(int index) const {
  return facet_.Get(index);
}
inline ::com::telenav::proto::Facet* SearchResult::mutable_facet(int index) {
  return facet_.Mutable(index);
}
inline ::com::telenav::proto::Facet* SearchResult::add_facet() {
  return facet_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet >&
SearchResult::facet() const {
  return facet_;
}
inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet >*
SearchResult::mutable_facet() {
  return &facet_;
}

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

// Entity

// optional string name = 1;
inline bool Entity::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Entity::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Entity::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Entity::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& Entity::name() const {
  return *name_;
}
inline void Entity::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Entity::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Entity::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Entity::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* Entity::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string entity_id = 2;
inline bool Entity::has_entity_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Entity::set_has_entity_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Entity::clear_has_entity_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Entity::clear_entity_id() {
  if (entity_id_ != &::google::protobuf::internal::kEmptyString) {
    entity_id_->clear();
  }
  clear_has_entity_id();
}
inline const ::std::string& Entity::entity_id() const {
  return *entity_id_;
}
inline void Entity::set_entity_id(const ::std::string& value) {
  set_has_entity_id();
  if (entity_id_ == &::google::protobuf::internal::kEmptyString) {
    entity_id_ = new ::std::string;
  }
  entity_id_->assign(value);
}
inline void Entity::set_entity_id(const char* value) {
  set_has_entity_id();
  if (entity_id_ == &::google::protobuf::internal::kEmptyString) {
    entity_id_ = new ::std::string;
  }
  entity_id_->assign(value);
}
inline void Entity::set_entity_id(const char* value, size_t size) {
  set_has_entity_id();
  if (entity_id_ == &::google::protobuf::internal::kEmptyString) {
    entity_id_ = new ::std::string;
  }
  entity_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Entity::mutable_entity_id() {
  set_has_entity_id();
  if (entity_id_ == &::google::protobuf::internal::kEmptyString) {
    entity_id_ = new ::std::string;
  }
  return entity_id_;
}
inline ::std::string* Entity::release_entity_id() {
  clear_has_entity_id();
  if (entity_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = entity_id_;
    entity_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string phone_number = 3;
inline bool Entity::has_phone_number() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Entity::set_has_phone_number() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Entity::clear_has_phone_number() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Entity::clear_phone_number() {
  if (phone_number_ != &::google::protobuf::internal::kEmptyString) {
    phone_number_->clear();
  }
  clear_has_phone_number();
}
inline const ::std::string& Entity::phone_number() const {
  return *phone_number_;
}
inline void Entity::set_phone_number(const ::std::string& value) {
  set_has_phone_number();
  if (phone_number_ == &::google::protobuf::internal::kEmptyString) {
    phone_number_ = new ::std::string;
  }
  phone_number_->assign(value);
}
inline void Entity::set_phone_number(const char* value) {
  set_has_phone_number();
  if (phone_number_ == &::google::protobuf::internal::kEmptyString) {
    phone_number_ = new ::std::string;
  }
  phone_number_->assign(value);
}
inline void Entity::set_phone_number(const char* value, size_t size) {
  set_has_phone_number();
  if (phone_number_ == &::google::protobuf::internal::kEmptyString) {
    phone_number_ = new ::std::string;
  }
  phone_number_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Entity::mutable_phone_number() {
  set_has_phone_number();
  if (phone_number_ == &::google::protobuf::internal::kEmptyString) {
    phone_number_ = new ::std::string;
  }
  return phone_number_;
}
inline ::std::string* Entity::release_phone_number() {
  clear_has_phone_number();
  if (phone_number_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = phone_number_;
    phone_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated string category = 4;
inline int Entity::category_size() const {
  return category_.size();
}
inline void Entity::clear_category() {
  category_.Clear();
}
inline const ::std::string& Entity::category(int index) const {
  return category_.Get(index);
}
inline ::std::string* Entity::mutable_category(int index) {
  return category_.Mutable(index);
}
inline void Entity::set_category(int index, const ::std::string& value) {
  category_.Mutable(index)->assign(value);
}
inline void Entity::set_category(int index, const char* value) {
  category_.Mutable(index)->assign(value);
}
inline void Entity::set_category(int index, const char* value, size_t size) {
  category_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Entity::add_category() {
  return category_.Add();
}
inline void Entity::add_category(const ::std::string& value) {
  category_.Add()->assign(value);
}
inline void Entity::add_category(const char* value) {
  category_.Add()->assign(value);
}
inline void Entity::add_category(const char* value, size_t size) {
  category_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
Entity::category() const {
  return category_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Entity::mutable_category() {
  return &category_;
}

// optional .com.telenav.proto.Address display_address = 5;
inline bool Entity::has_display_address() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Entity::set_has_display_address() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Entity::clear_has_display_address() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Entity::clear_display_address() {
  if (display_address_ != NULL) display_address_->::com::telenav::proto::Address::Clear();
  clear_has_display_address();
}
inline const ::com::telenav::proto::Address& Entity::display_address() const {
  return display_address_ != NULL ? *display_address_ : *default_instance_->display_address_;
}
inline ::com::telenav::proto::Address* Entity::mutable_display_address() {
  set_has_display_address();
  if (display_address_ == NULL) display_address_ = new ::com::telenav::proto::Address;
  return display_address_;
}
inline ::com::telenav::proto::Address* Entity::release_display_address() {
  clear_has_display_address();
  ::com::telenav::proto::Address* temp = display_address_;
  display_address_ = NULL;
  return temp;
}

// optional .com.telenav.proto.LatLon rooftop_geocode = 6;
inline bool Entity::has_rooftop_geocode() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Entity::set_has_rooftop_geocode() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Entity::clear_has_rooftop_geocode() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Entity::clear_rooftop_geocode() {
  if (rooftop_geocode_ != NULL) rooftop_geocode_->::com::telenav::proto::LatLon::Clear();
  clear_has_rooftop_geocode();
}
inline const ::com::telenav::proto::LatLon& Entity::rooftop_geocode() const {
  return rooftop_geocode_ != NULL ? *rooftop_geocode_ : *default_instance_->rooftop_geocode_;
}
inline ::com::telenav::proto::LatLon* Entity::mutable_rooftop_geocode() {
  set_has_rooftop_geocode();
  if (rooftop_geocode_ == NULL) rooftop_geocode_ = new ::com::telenav::proto::LatLon;
  return rooftop_geocode_;
}
inline ::com::telenav::proto::LatLon* Entity::release_rooftop_geocode() {
  clear_has_rooftop_geocode();
  ::com::telenav::proto::LatLon* temp = rooftop_geocode_;
  rooftop_geocode_ = NULL;
  return temp;
}

// repeated .com.telenav.proto.LatLon entrance_geocode = 7;
inline int Entity::entrance_geocode_size() const {
  return entrance_geocode_.size();
}
inline void Entity::clear_entrance_geocode() {
  entrance_geocode_.Clear();
}
inline const ::com::telenav::proto::LatLon& Entity::entrance_geocode(int index) const {
  return entrance_geocode_.Get(index);
}
inline ::com::telenav::proto::LatLon* Entity::mutable_entrance_geocode(int index) {
  return entrance_geocode_.Mutable(index);
}
inline ::com::telenav::proto::LatLon* Entity::add_entrance_geocode() {
  return entrance_geocode_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon >&
Entity::entrance_geocode() const {
  return entrance_geocode_;
}
inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::LatLon >*
Entity::mutable_entrance_geocode() {
  return &entrance_geocode_;
}

// optional string logo_url = 8;
inline bool Entity::has_logo_url() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Entity::set_has_logo_url() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Entity::clear_has_logo_url() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Entity::clear_logo_url() {
  if (logo_url_ != &::google::protobuf::internal::kEmptyString) {
    logo_url_->clear();
  }
  clear_has_logo_url();
}
inline const ::std::string& Entity::logo_url() const {
  return *logo_url_;
}
inline void Entity::set_logo_url(const ::std::string& value) {
  set_has_logo_url();
  if (logo_url_ == &::google::protobuf::internal::kEmptyString) {
    logo_url_ = new ::std::string;
  }
  logo_url_->assign(value);
}
inline void Entity::set_logo_url(const char* value) {
  set_has_logo_url();
  if (logo_url_ == &::google::protobuf::internal::kEmptyString) {
    logo_url_ = new ::std::string;
  }
  logo_url_->assign(value);
}
inline void Entity::set_logo_url(const char* value, size_t size) {
  set_has_logo_url();
  if (logo_url_ == &::google::protobuf::internal::kEmptyString) {
    logo_url_ = new ::std::string;
  }
  logo_url_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Entity::mutable_logo_url() {
  set_has_logo_url();
  if (logo_url_ == &::google::protobuf::internal::kEmptyString) {
    logo_url_ = new ::std::string;
  }
  return logo_url_;
}
inline ::std::string* Entity::release_logo_url() {
  clear_has_logo_url();
  if (logo_url_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = logo_url_;
    logo_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string website = 9;
inline bool Entity::has_website() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Entity::set_has_website() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Entity::clear_has_website() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Entity::clear_website() {
  if (website_ != &::google::protobuf::internal::kEmptyString) {
    website_->clear();
  }
  clear_has_website();
}
inline const ::std::string& Entity::website() const {
  return *website_;
}
inline void Entity::set_website(const ::std::string& value) {
  set_has_website();
  if (website_ == &::google::protobuf::internal::kEmptyString) {
    website_ = new ::std::string;
  }
  website_->assign(value);
}
inline void Entity::set_website(const char* value) {
  set_has_website();
  if (website_ == &::google::protobuf::internal::kEmptyString) {
    website_ = new ::std::string;
  }
  website_->assign(value);
}
inline void Entity::set_website(const char* value, size_t size) {
  set_has_website();
  if (website_ == &::google::protobuf::internal::kEmptyString) {
    website_ = new ::std::string;
  }
  website_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Entity::mutable_website() {
  set_has_website();
  if (website_ == &::google::protobuf::internal::kEmptyString) {
    website_ = new ::std::string;
  }
  return website_;
}
inline ::std::string* Entity::release_website() {
  clear_has_website();
  if (website_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = website_;
    website_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string olson_timezone = 10;
inline bool Entity::has_olson_timezone() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Entity::set_has_olson_timezone() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Entity::clear_has_olson_timezone() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Entity::clear_olson_timezone() {
  if (olson_timezone_ != &::google::protobuf::internal::kEmptyString) {
    olson_timezone_->clear();
  }
  clear_has_olson_timezone();
}
inline const ::std::string& Entity::olson_timezone() const {
  return *olson_timezone_;
}
inline void Entity::set_olson_timezone(const ::std::string& value) {
  set_has_olson_timezone();
  if (olson_timezone_ == &::google::protobuf::internal::kEmptyString) {
    olson_timezone_ = new ::std::string;
  }
  olson_timezone_->assign(value);
}
inline void Entity::set_olson_timezone(const char* value) {
  set_has_olson_timezone();
  if (olson_timezone_ == &::google::protobuf::internal::kEmptyString) {
    olson_timezone_ = new ::std::string;
  }
  olson_timezone_->assign(value);
}
inline void Entity::set_olson_timezone(const char* value, size_t size) {
  set_has_olson_timezone();
  if (olson_timezone_ == &::google::protobuf::internal::kEmptyString) {
    olson_timezone_ = new ::std::string;
  }
  olson_timezone_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Entity::mutable_olson_timezone() {
  set_has_olson_timezone();
  if (olson_timezone_ == &::google::protobuf::internal::kEmptyString) {
    olson_timezone_ = new ::std::string;
  }
  return olson_timezone_;
}
inline ::std::string* Entity::release_olson_timezone() {
  clear_has_olson_timezone();
  if (olson_timezone_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = olson_timezone_;
    olson_timezone_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string email = 11;
inline bool Entity::has_email() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Entity::set_has_email() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Entity::clear_has_email() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Entity::clear_email() {
  if (email_ != &::google::protobuf::internal::kEmptyString) {
    email_->clear();
  }
  clear_has_email();
}
inline const ::std::string& Entity::email() const {
  return *email_;
}
inline void Entity::set_email(const ::std::string& value) {
  set_has_email();
  if (email_ == &::google::protobuf::internal::kEmptyString) {
    email_ = new ::std::string;
  }
  email_->assign(value);
}
inline void Entity::set_email(const char* value) {
  set_has_email();
  if (email_ == &::google::protobuf::internal::kEmptyString) {
    email_ = new ::std::string;
  }
  email_->assign(value);
}
inline void Entity::set_email(const char* value, size_t size) {
  set_has_email();
  if (email_ == &::google::protobuf::internal::kEmptyString) {
    email_ = new ::std::string;
  }
  email_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Entity::mutable_email() {
  set_has_email();
  if (email_ == &::google::protobuf::internal::kEmptyString) {
    email_ = new ::std::string;
  }
  return email_;
}
inline ::std::string* Entity::release_email() {
  clear_has_email();
  if (email_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = email_;
    email_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required .com.telenav.proto.EntityType entity_type = 99;
inline bool Entity::has_entity_type() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Entity::set_has_entity_type() {
  _has_bits_[0] |= 0x00000800u;
}
inline void Entity::clear_has_entity_type() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void Entity::clear_entity_type() {
  entity_type_ = 1;
  clear_has_entity_type();
}
inline com::telenav::proto::EntityType Entity::entity_type() const {
  return static_cast< com::telenav::proto::EntityType >(entity_type_);
}
inline void Entity::set_entity_type(com::telenav::proto::EntityType value) {
  GOOGLE_DCHECK(com::telenav::proto::EntityType_IsValid(value));
  set_has_entity_type();
  entity_type_ = value;
}

// optional string old_entity_id = 101;
inline bool Entity::has_old_entity_id() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void Entity::set_has_old_entity_id() {
  _has_bits_[0] |= 0x00001000u;
}
inline void Entity::clear_has_old_entity_id() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void Entity::clear_old_entity_id() {
  if (old_entity_id_ != &::google::protobuf::internal::kEmptyString) {
    old_entity_id_->clear();
  }
  clear_has_old_entity_id();
}
inline const ::std::string& Entity::old_entity_id() const {
  return *old_entity_id_;
}
inline void Entity::set_old_entity_id(const ::std::string& value) {
  set_has_old_entity_id();
  if (old_entity_id_ == &::google::protobuf::internal::kEmptyString) {
    old_entity_id_ = new ::std::string;
  }
  old_entity_id_->assign(value);
}
inline void Entity::set_old_entity_id(const char* value) {
  set_has_old_entity_id();
  if (old_entity_id_ == &::google::protobuf::internal::kEmptyString) {
    old_entity_id_ = new ::std::string;
  }
  old_entity_id_->assign(value);
}
inline void Entity::set_old_entity_id(const char* value, size_t size) {
  set_has_old_entity_id();
  if (old_entity_id_ == &::google::protobuf::internal::kEmptyString) {
    old_entity_id_ = new ::std::string;
  }
  old_entity_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Entity::mutable_old_entity_id() {
  set_has_old_entity_id();
  if (old_entity_id_ == &::google::protobuf::internal::kEmptyString) {
    old_entity_id_ = new ::std::string;
  }
  return old_entity_id_;
}
inline ::std::string* Entity::release_old_entity_id() {
  clear_has_old_entity_id();
  if (old_entity_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = old_entity_id_;
    old_entity_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// EntityDetail

// required .com.telenav.proto.Entity entity = 1;
inline bool EntityDetail::has_entity() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EntityDetail::set_has_entity() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EntityDetail::clear_has_entity() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EntityDetail::clear_entity() {
  if (entity_ != NULL) entity_->::com::telenav::proto::Entity::Clear();
  clear_has_entity();
}
inline const ::com::telenav::proto::Entity& EntityDetail::entity() const {
  return entity_ != NULL ? *entity_ : *default_instance_->entity_;
}
inline ::com::telenav::proto::Entity* EntityDetail::mutable_entity() {
  set_has_entity();
  if (entity_ == NULL) entity_ = new ::com::telenav::proto::Entity;
  return entity_;
}
inline ::com::telenav::proto::Entity* EntityDetail::release_entity() {
  clear_has_entity();
  ::com::telenav::proto::Entity* temp = entity_;
  entity_ = NULL;
  return temp;
}

// repeated string availableFacet = 2;
inline int EntityDetail::availablefacet_size() const {
  return availablefacet_.size();
}
inline void EntityDetail::clear_availablefacet() {
  availablefacet_.Clear();
}
inline const ::std::string& EntityDetail::availablefacet(int index) const {
  return availablefacet_.Get(index);
}
inline ::std::string* EntityDetail::mutable_availablefacet(int index) {
  return availablefacet_.Mutable(index);
}
inline void EntityDetail::set_availablefacet(int index, const ::std::string& value) {
  availablefacet_.Mutable(index)->assign(value);
}
inline void EntityDetail::set_availablefacet(int index, const char* value) {
  availablefacet_.Mutable(index)->assign(value);
}
inline void EntityDetail::set_availablefacet(int index, const char* value, size_t size) {
  availablefacet_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntityDetail::add_availablefacet() {
  return availablefacet_.Add();
}
inline void EntityDetail::add_availablefacet(const ::std::string& value) {
  availablefacet_.Add()->assign(value);
}
inline void EntityDetail::add_availablefacet(const char* value) {
  availablefacet_.Add()->assign(value);
}
inline void EntityDetail::add_availablefacet(const char* value, size_t size) {
  availablefacet_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
EntityDetail::availablefacet() const {
  return availablefacet_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
EntityDetail::mutable_availablefacet() {
  return &availablefacet_;
}

// repeated .com.telenav.proto.Facet facet = 3;
inline int EntityDetail::facet_size() const {
  return facet_.size();
}
inline void EntityDetail::clear_facet() {
  facet_.Clear();
}
inline const ::com::telenav::proto::Facet& EntityDetail::facet(int index) const {
  return facet_.Get(index);
}
inline ::com::telenav::proto::Facet* EntityDetail::mutable_facet(int index) {
  return facet_.Mutable(index);
}
inline ::com::telenav::proto::Facet* EntityDetail::add_facet() {
  return facet_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet >&
EntityDetail::facet() const {
  return facet_;
}
inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::Facet >*
EntityDetail::mutable_facet() {
  return &facet_;
}

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

// EntityDetailRequest

// optional string request_id = 1;
inline bool EntityDetailRequest::has_request_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EntityDetailRequest::set_has_request_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EntityDetailRequest::clear_has_request_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EntityDetailRequest::clear_request_id() {
  if (request_id_ != &::google::protobuf::internal::kEmptyString) {
    request_id_->clear();
  }
  clear_has_request_id();
}
inline const ::std::string& EntityDetailRequest::request_id() const {
  return *request_id_;
}
inline void EntityDetailRequest::set_request_id(const ::std::string& value) {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  request_id_->assign(value);
}
inline void EntityDetailRequest::set_request_id(const char* value) {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  request_id_->assign(value);
}
inline void EntityDetailRequest::set_request_id(const char* value, size_t size) {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  request_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntityDetailRequest::mutable_request_id() {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  return request_id_;
}
inline ::std::string* EntityDetailRequest::release_request_id() {
  clear_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = request_id_;
    request_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required .com.telenav.proto.Context context = 2;
inline bool EntityDetailRequest::has_context() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EntityDetailRequest::set_has_context() {
  _has_bits_[0] |= 0x00000002u;
}
inline void EntityDetailRequest::clear_has_context() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void EntityDetailRequest::clear_context() {
  if (context_ != NULL) context_->::com::telenav::proto::Context::Clear();
  clear_has_context();
}
inline const ::com::telenav::proto::Context& EntityDetailRequest::context() const {
  return context_ != NULL ? *context_ : *default_instance_->context_;
}
inline ::com::telenav::proto::Context* EntityDetailRequest::mutable_context() {
  set_has_context();
  if (context_ == NULL) context_ = new ::com::telenav::proto::Context;
  return context_;
}
inline ::com::telenav::proto::Context* EntityDetailRequest::release_context() {
  clear_has_context();
  ::com::telenav::proto::Context* temp = context_;
  context_ = NULL;
  return temp;
}

// repeated string entity_id = 10;
inline int EntityDetailRequest::entity_id_size() const {
  return entity_id_.size();
}
inline void EntityDetailRequest::clear_entity_id() {
  entity_id_.Clear();
}
inline const ::std::string& EntityDetailRequest::entity_id(int index) const {
  return entity_id_.Get(index);
}
inline ::std::string* EntityDetailRequest::mutable_entity_id(int index) {
  return entity_id_.Mutable(index);
}
inline void EntityDetailRequest::set_entity_id(int index, const ::std::string& value) {
  entity_id_.Mutable(index)->assign(value);
}
inline void EntityDetailRequest::set_entity_id(int index, const char* value) {
  entity_id_.Mutable(index)->assign(value);
}
inline void EntityDetailRequest::set_entity_id(int index, const char* value, size_t size) {
  entity_id_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntityDetailRequest::add_entity_id() {
  return entity_id_.Add();
}
inline void EntityDetailRequest::add_entity_id(const ::std::string& value) {
  entity_id_.Add()->assign(value);
}
inline void EntityDetailRequest::add_entity_id(const char* value) {
  entity_id_.Add()->assign(value);
}
inline void EntityDetailRequest::add_entity_id(const char* value, size_t size) {
  entity_id_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
EntityDetailRequest::entity_id() const {
  return entity_id_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
EntityDetailRequest::mutable_entity_id() {
  return &entity_id_;
}

// repeated string facet = 11;
inline int EntityDetailRequest::facet_size() const {
  return facet_.size();
}
inline void EntityDetailRequest::clear_facet() {
  facet_.Clear();
}
inline const ::std::string& EntityDetailRequest::facet(int index) const {
  return facet_.Get(index);
}
inline ::std::string* EntityDetailRequest::mutable_facet(int index) {
  return facet_.Mutable(index);
}
inline void EntityDetailRequest::set_facet(int index, const ::std::string& value) {
  facet_.Mutable(index)->assign(value);
}
inline void EntityDetailRequest::set_facet(int index, const char* value) {
  facet_.Mutable(index)->assign(value);
}
inline void EntityDetailRequest::set_facet(int index, const char* value, size_t size) {
  facet_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntityDetailRequest::add_facet() {
  return facet_.Add();
}
inline void EntityDetailRequest::add_facet(const ::std::string& value) {
  facet_.Add()->assign(value);
}
inline void EntityDetailRequest::add_facet(const char* value) {
  facet_.Add()->assign(value);
}
inline void EntityDetailRequest::add_facet(const char* value, size_t size) {
  facet_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
EntityDetailRequest::facet() const {
  return facet_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
EntityDetailRequest::mutable_facet() {
  return &facet_;
}

// optional string geo_source = 15;
inline bool EntityDetailRequest::has_geo_source() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void EntityDetailRequest::set_has_geo_source() {
  _has_bits_[0] |= 0x00000010u;
}
inline void EntityDetailRequest::clear_has_geo_source() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void EntityDetailRequest::clear_geo_source() {
  if (geo_source_ != &::google::protobuf::internal::kEmptyString) {
    geo_source_->clear();
  }
  clear_has_geo_source();
}
inline const ::std::string& EntityDetailRequest::geo_source() const {
  return *geo_source_;
}
inline void EntityDetailRequest::set_geo_source(const ::std::string& value) {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  geo_source_->assign(value);
}
inline void EntityDetailRequest::set_geo_source(const char* value) {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  geo_source_->assign(value);
}
inline void EntityDetailRequest::set_geo_source(const char* value, size_t size) {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  geo_source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntityDetailRequest::mutable_geo_source() {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  return geo_source_;
}
inline ::std::string* EntityDetailRequest::release_geo_source() {
  clear_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = geo_source_;
    geo_source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string entity_source = 16;
inline bool EntityDetailRequest::has_entity_source() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void EntityDetailRequest::set_has_entity_source() {
  _has_bits_[0] |= 0x00000020u;
}
inline void EntityDetailRequest::clear_has_entity_source() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void EntityDetailRequest::clear_entity_source() {
  if (entity_source_ != &::google::protobuf::internal::kEmptyString) {
    entity_source_->clear();
  }
  clear_has_entity_source();
}
inline const ::std::string& EntityDetailRequest::entity_source() const {
  return *entity_source_;
}
inline void EntityDetailRequest::set_entity_source(const ::std::string& value) {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  entity_source_->assign(value);
}
inline void EntityDetailRequest::set_entity_source(const char* value) {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  entity_source_->assign(value);
}
inline void EntityDetailRequest::set_entity_source(const char* value, size_t size) {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  entity_source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntityDetailRequest::mutable_entity_source() {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  return entity_source_;
}
inline ::std::string* EntityDetailRequest::release_entity_source() {
  clear_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = entity_source_;
    entity_source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated .com.telenav.proto.NameValuePair facet_params = 20;
inline int EntityDetailRequest::facet_params_size() const {
  return facet_params_.size();
}
inline void EntityDetailRequest::clear_facet_params() {
  facet_params_.Clear();
}
inline const ::com::telenav::proto::NameValuePair& EntityDetailRequest::facet_params(int index) const {
  return facet_params_.Get(index);
}
inline ::com::telenav::proto::NameValuePair* EntityDetailRequest::mutable_facet_params(int index) {
  return facet_params_.Mutable(index);
}
inline ::com::telenav::proto::NameValuePair* EntityDetailRequest::add_facet_params() {
  return facet_params_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::NameValuePair >&
EntityDetailRequest::facet_params() const {
  return facet_params_;
}
inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::NameValuePair >*
EntityDetailRequest::mutable_facet_params() {
  return &facet_params_;
}

// optional string lang = 30;
inline bool EntityDetailRequest::has_lang() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void EntityDetailRequest::set_has_lang() {
  _has_bits_[0] |= 0x00000080u;
}
inline void EntityDetailRequest::clear_has_lang() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void EntityDetailRequest::clear_lang() {
  if (lang_ != &::google::protobuf::internal::kEmptyString) {
    lang_->clear();
  }
  clear_has_lang();
}
inline const ::std::string& EntityDetailRequest::lang() const {
  return *lang_;
}
inline void EntityDetailRequest::set_lang(const ::std::string& value) {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  lang_->assign(value);
}
inline void EntityDetailRequest::set_lang(const char* value) {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  lang_->assign(value);
}
inline void EntityDetailRequest::set_lang(const char* value, size_t size) {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  lang_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntityDetailRequest::mutable_lang() {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  return lang_;
}
inline ::std::string* EntityDetailRequest::release_lang() {
  clear_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = lang_;
    lang_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// EntityDetailResponse

// required .com.telenav.proto.ServiceStatus status = 1;
inline bool EntityDetailResponse::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EntityDetailResponse::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EntityDetailResponse::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EntityDetailResponse::clear_status() {
  if (status_ != NULL) status_->::com::telenav::proto::ServiceStatus::Clear();
  clear_has_status();
}
inline const ::com::telenav::proto::ServiceStatus& EntityDetailResponse::status() const {
  return status_ != NULL ? *status_ : *default_instance_->status_;
}
inline ::com::telenav::proto::ServiceStatus* EntityDetailResponse::mutable_status() {
  set_has_status();
  if (status_ == NULL) status_ = new ::com::telenav::proto::ServiceStatus;
  return status_;
}
inline ::com::telenav::proto::ServiceStatus* EntityDetailResponse::release_status() {
  clear_has_status();
  ::com::telenav::proto::ServiceStatus* temp = status_;
  status_ = NULL;
  return temp;
}

// repeated .com.telenav.proto.EntityDetail entity_detail = 10;
inline int EntityDetailResponse::entity_detail_size() const {
  return entity_detail_.size();
}
inline void EntityDetailResponse::clear_entity_detail() {
  entity_detail_.Clear();
}
inline const ::com::telenav::proto::EntityDetail& EntityDetailResponse::entity_detail(int index) const {
  return entity_detail_.Get(index);
}
inline ::com::telenav::proto::EntityDetail* EntityDetailResponse::mutable_entity_detail(int index) {
  return entity_detail_.Mutable(index);
}
inline ::com::telenav::proto::EntityDetail* EntityDetailResponse::add_entity_detail() {
  return entity_detail_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntityDetail >&
EntityDetailResponse::entity_detail() const {
  return entity_detail_;
}
inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntityDetail >*
EntityDetailResponse::mutable_entity_detail() {
  return &entity_detail_;
}

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

// EntitySuggestionsRequest

// optional string request_id = 1;
inline bool EntitySuggestionsRequest::has_request_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EntitySuggestionsRequest::set_has_request_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EntitySuggestionsRequest::clear_has_request_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EntitySuggestionsRequest::clear_request_id() {
  if (request_id_ != &::google::protobuf::internal::kEmptyString) {
    request_id_->clear();
  }
  clear_has_request_id();
}
inline const ::std::string& EntitySuggestionsRequest::request_id() const {
  return *request_id_;
}
inline void EntitySuggestionsRequest::set_request_id(const ::std::string& value) {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  request_id_->assign(value);
}
inline void EntitySuggestionsRequest::set_request_id(const char* value) {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  request_id_->assign(value);
}
inline void EntitySuggestionsRequest::set_request_id(const char* value, size_t size) {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  request_id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySuggestionsRequest::mutable_request_id() {
  set_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    request_id_ = new ::std::string;
  }
  return request_id_;
}
inline ::std::string* EntitySuggestionsRequest::release_request_id() {
  clear_has_request_id();
  if (request_id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = request_id_;
    request_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required .com.telenav.proto.Context context = 2;
inline bool EntitySuggestionsRequest::has_context() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EntitySuggestionsRequest::set_has_context() {
  _has_bits_[0] |= 0x00000002u;
}
inline void EntitySuggestionsRequest::clear_has_context() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void EntitySuggestionsRequest::clear_context() {
  if (context_ != NULL) context_->::com::telenav::proto::Context::Clear();
  clear_has_context();
}
inline const ::com::telenav::proto::Context& EntitySuggestionsRequest::context() const {
  return context_ != NULL ? *context_ : *default_instance_->context_;
}
inline ::com::telenav::proto::Context* EntitySuggestionsRequest::mutable_context() {
  set_has_context();
  if (context_ == NULL) context_ = new ::com::telenav::proto::Context;
  return context_;
}
inline ::com::telenav::proto::Context* EntitySuggestionsRequest::release_context() {
  clear_has_context();
  ::com::telenav::proto::Context* temp = context_;
  context_ = NULL;
  return temp;
}

// required string keyword = 10;
inline bool EntitySuggestionsRequest::has_keyword() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void EntitySuggestionsRequest::set_has_keyword() {
  _has_bits_[0] |= 0x00000004u;
}
inline void EntitySuggestionsRequest::clear_has_keyword() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void EntitySuggestionsRequest::clear_keyword() {
  if (keyword_ != &::google::protobuf::internal::kEmptyString) {
    keyword_->clear();
  }
  clear_has_keyword();
}
inline const ::std::string& EntitySuggestionsRequest::keyword() const {
  return *keyword_;
}
inline void EntitySuggestionsRequest::set_keyword(const ::std::string& value) {
  set_has_keyword();
  if (keyword_ == &::google::protobuf::internal::kEmptyString) {
    keyword_ = new ::std::string;
  }
  keyword_->assign(value);
}
inline void EntitySuggestionsRequest::set_keyword(const char* value) {
  set_has_keyword();
  if (keyword_ == &::google::protobuf::internal::kEmptyString) {
    keyword_ = new ::std::string;
  }
  keyword_->assign(value);
}
inline void EntitySuggestionsRequest::set_keyword(const char* value, size_t size) {
  set_has_keyword();
  if (keyword_ == &::google::protobuf::internal::kEmptyString) {
    keyword_ = new ::std::string;
  }
  keyword_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySuggestionsRequest::mutable_keyword() {
  set_has_keyword();
  if (keyword_ == &::google::protobuf::internal::kEmptyString) {
    keyword_ = new ::std::string;
  }
  return keyword_;
}
inline ::std::string* EntitySuggestionsRequest::release_keyword() {
  clear_has_keyword();
  if (keyword_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = keyword_;
    keyword_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string current_location = 11;
inline bool EntitySuggestionsRequest::has_current_location() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void EntitySuggestionsRequest::set_has_current_location() {
  _has_bits_[0] |= 0x00000008u;
}
inline void EntitySuggestionsRequest::clear_has_current_location() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void EntitySuggestionsRequest::clear_current_location() {
  if (current_location_ != &::google::protobuf::internal::kEmptyString) {
    current_location_->clear();
  }
  clear_has_current_location();
}
inline const ::std::string& EntitySuggestionsRequest::current_location() const {
  return *current_location_;
}
inline void EntitySuggestionsRequest::set_current_location(const ::std::string& value) {
  set_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    current_location_ = new ::std::string;
  }
  current_location_->assign(value);
}
inline void EntitySuggestionsRequest::set_current_location(const char* value) {
  set_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    current_location_ = new ::std::string;
  }
  current_location_->assign(value);
}
inline void EntitySuggestionsRequest::set_current_location(const char* value, size_t size) {
  set_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    current_location_ = new ::std::string;
  }
  current_location_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySuggestionsRequest::mutable_current_location() {
  set_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    current_location_ = new ::std::string;
  }
  return current_location_;
}
inline ::std::string* EntitySuggestionsRequest::release_current_location() {
  clear_has_current_location();
  if (current_location_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = current_location_;
    current_location_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional .com.telenav.proto.SuggestionsType type = 20 [default = ALL_SUGGESTIONS];
inline bool EntitySuggestionsRequest::has_type() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void EntitySuggestionsRequest::set_has_type() {
  _has_bits_[0] |= 0x00000010u;
}
inline void EntitySuggestionsRequest::clear_has_type() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void EntitySuggestionsRequest::clear_type() {
  type_ = 100;
  clear_has_type();
}
inline com::telenav::proto::SuggestionsType EntitySuggestionsRequest::type() const {
  return static_cast< com::telenav::proto::SuggestionsType >(type_);
}
inline void EntitySuggestionsRequest::set_type(com::telenav::proto::SuggestionsType value) {
  GOOGLE_DCHECK(com::telenav::proto::SuggestionsType_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional string geo_source = 30;
inline bool EntitySuggestionsRequest::has_geo_source() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void EntitySuggestionsRequest::set_has_geo_source() {
  _has_bits_[0] |= 0x00000020u;
}
inline void EntitySuggestionsRequest::clear_has_geo_source() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void EntitySuggestionsRequest::clear_geo_source() {
  if (geo_source_ != &::google::protobuf::internal::kEmptyString) {
    geo_source_->clear();
  }
  clear_has_geo_source();
}
inline const ::std::string& EntitySuggestionsRequest::geo_source() const {
  return *geo_source_;
}
inline void EntitySuggestionsRequest::set_geo_source(const ::std::string& value) {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  geo_source_->assign(value);
}
inline void EntitySuggestionsRequest::set_geo_source(const char* value) {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  geo_source_->assign(value);
}
inline void EntitySuggestionsRequest::set_geo_source(const char* value, size_t size) {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  geo_source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySuggestionsRequest::mutable_geo_source() {
  set_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    geo_source_ = new ::std::string;
  }
  return geo_source_;
}
inline ::std::string* EntitySuggestionsRequest::release_geo_source() {
  clear_has_geo_source();
  if (geo_source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = geo_source_;
    geo_source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string entity_source = 31;
inline bool EntitySuggestionsRequest::has_entity_source() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void EntitySuggestionsRequest::set_has_entity_source() {
  _has_bits_[0] |= 0x00000040u;
}
inline void EntitySuggestionsRequest::clear_has_entity_source() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void EntitySuggestionsRequest::clear_entity_source() {
  if (entity_source_ != &::google::protobuf::internal::kEmptyString) {
    entity_source_->clear();
  }
  clear_has_entity_source();
}
inline const ::std::string& EntitySuggestionsRequest::entity_source() const {
  return *entity_source_;
}
inline void EntitySuggestionsRequest::set_entity_source(const ::std::string& value) {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  entity_source_->assign(value);
}
inline void EntitySuggestionsRequest::set_entity_source(const char* value) {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  entity_source_->assign(value);
}
inline void EntitySuggestionsRequest::set_entity_source(const char* value, size_t size) {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  entity_source_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySuggestionsRequest::mutable_entity_source() {
  set_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    entity_source_ = new ::std::string;
  }
  return entity_source_;
}
inline ::std::string* EntitySuggestionsRequest::release_entity_source() {
  clear_has_entity_source();
  if (entity_source_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = entity_source_;
    entity_source_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string lang = 50;
inline bool EntitySuggestionsRequest::has_lang() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void EntitySuggestionsRequest::set_has_lang() {
  _has_bits_[0] |= 0x00000080u;
}
inline void EntitySuggestionsRequest::clear_has_lang() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void EntitySuggestionsRequest::clear_lang() {
  if (lang_ != &::google::protobuf::internal::kEmptyString) {
    lang_->clear();
  }
  clear_has_lang();
}
inline const ::std::string& EntitySuggestionsRequest::lang() const {
  return *lang_;
}
inline void EntitySuggestionsRequest::set_lang(const ::std::string& value) {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  lang_->assign(value);
}
inline void EntitySuggestionsRequest::set_lang(const char* value) {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  lang_->assign(value);
}
inline void EntitySuggestionsRequest::set_lang(const char* value, size_t size) {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  lang_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* EntitySuggestionsRequest::mutable_lang() {
  set_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    lang_ = new ::std::string;
  }
  return lang_;
}
inline ::std::string* EntitySuggestionsRequest::release_lang() {
  clear_has_lang();
  if (lang_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = lang_;
    lang_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 limit = 100 [default = 10];
inline bool EntitySuggestionsRequest::has_limit() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void EntitySuggestionsRequest::set_has_limit() {
  _has_bits_[0] |= 0x00000100u;
}
inline void EntitySuggestionsRequest::clear_has_limit() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void EntitySuggestionsRequest::clear_limit() {
  limit_ = 10;
  clear_has_limit();
}
inline ::google::protobuf::int32 EntitySuggestionsRequest::limit() const {
  return limit_;
}
inline void EntitySuggestionsRequest::set_limit(::google::protobuf::int32 value) {
  set_has_limit();
  limit_ = value;
}

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

// EntitySuggestionsResponse

// required .com.telenav.proto.ServiceStatus status = 1;
inline bool EntitySuggestionsResponse::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EntitySuggestionsResponse::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EntitySuggestionsResponse::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EntitySuggestionsResponse::clear_status() {
  if (status_ != NULL) status_->::com::telenav::proto::ServiceStatus::Clear();
  clear_has_status();
}
inline const ::com::telenav::proto::ServiceStatus& EntitySuggestionsResponse::status() const {
  return status_ != NULL ? *status_ : *default_instance_->status_;
}
inline ::com::telenav::proto::ServiceStatus* EntitySuggestionsResponse::mutable_status() {
  set_has_status();
  if (status_ == NULL) status_ = new ::com::telenav::proto::ServiceStatus;
  return status_;
}
inline ::com::telenav::proto::ServiceStatus* EntitySuggestionsResponse::release_status() {
  clear_has_status();
  ::com::telenav::proto::ServiceStatus* temp = status_;
  status_ = NULL;
  return temp;
}

// repeated .com.telenav.proto.EntitySuggestionsResult result = 10;
inline int EntitySuggestionsResponse::result_size() const {
  return result_.size();
}
inline void EntitySuggestionsResponse::clear_result() {
  result_.Clear();
}
inline const ::com::telenav::proto::EntitySuggestionsResult& EntitySuggestionsResponse::result(int index) const {
  return result_.Get(index);
}
inline ::com::telenav::proto::EntitySuggestionsResult* EntitySuggestionsResponse::mutable_result(int index) {
  return result_.Mutable(index);
}
inline ::com::telenav::proto::EntitySuggestionsResult* EntitySuggestionsResponse::add_result() {
  return result_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntitySuggestionsResult >&
EntitySuggestionsResponse::result() const {
  return result_;
}
inline ::google::protobuf::RepeatedPtrField< ::com::telenav::proto::EntitySuggestionsResult >*
EntitySuggestionsResponse::mutable_result() {
  return &result_;
}

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

// EntitySuggestionsResult

// required .com.telenav.proto.QuerySuggestion suggestion = 1;
inline bool EntitySuggestionsResult::has_suggestion() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EntitySuggestionsResult::set_has_suggestion() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EntitySuggestionsResult::clear_has_suggestion() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EntitySuggestionsResult::clear_suggestion() {
  if (suggestion_ != NULL) suggestion_->::com::telenav::proto::QuerySuggestion::Clear();
  clear_has_suggestion();
}
inline const ::com::telenav::proto::QuerySuggestion& EntitySuggestionsResult::suggestion() const {
  return suggestion_ != NULL ? *suggestion_ : *default_instance_->suggestion_;
}
inline ::com::telenav::proto::QuerySuggestion* EntitySuggestionsResult::mutable_suggestion() {
  set_has_suggestion();
  if (suggestion_ == NULL) suggestion_ = new ::com::telenav::proto::QuerySuggestion;
  return suggestion_;
}
inline ::com::telenav::proto::QuerySuggestion* EntitySuggestionsResult::release_suggestion() {
  clear_has_suggestion();
  ::com::telenav::proto::QuerySuggestion* temp = suggestion_;
  suggestion_ = NULL;
  return temp;
}

// optional .com.telenav.proto.LatLon suggestion_location = 2;
inline bool EntitySuggestionsResult::has_suggestion_location() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EntitySuggestionsResult::set_has_suggestion_location() {
  _has_bits_[0] |= 0x00000002u;
}
inline void EntitySuggestionsResult::clear_has_suggestion_location() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void EntitySuggestionsResult::clear_suggestion_location() {
  if (suggestion_location_ != NULL) suggestion_location_->::com::telenav::proto::LatLon::Clear();
  clear_has_suggestion_location();
}
inline const ::com::telenav::proto::LatLon& EntitySuggestionsResult::suggestion_location() const {
  return suggestion_location_ != NULL ? *suggestion_location_ : *default_instance_->suggestion_location_;
}
inline ::com::telenav::proto::LatLon* EntitySuggestionsResult::mutable_suggestion_location() {
  set_has_suggestion_location();
  if (suggestion_location_ == NULL) suggestion_location_ = new ::com::telenav::proto::LatLon;
  return suggestion_location_;
}
inline ::com::telenav::proto::LatLon* EntitySuggestionsResult::release_suggestion_location() {
  clear_has_suggestion_location();
  ::com::telenav::proto::LatLon* temp = suggestion_location_;
  suggestion_location_ = NULL;
  return temp;
}

// optional double score = 10;
inline bool EntitySuggestionsResult::has_score() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void EntitySuggestionsResult::set_has_score() {
  _has_bits_[0] |= 0x00000004u;
}
inline void EntitySuggestionsResult::clear_has_score() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void EntitySuggestionsResult::clear_score() {
  score_ = 0;
  clear_has_score();
}
inline double EntitySuggestionsResult::score() const {
  return score_;
}
inline void EntitySuggestionsResult::set_score(double value) {
  set_has_score();
  score_ = value;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace proto
}  // namespace telenav
}  // namespace com

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_entity_2eproto__INCLUDED
