text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: dictionary/user_dictionary_storage.proto
  
  #ifndef PROTOBUF_dictionary_2fuser_5fdictionary_5fstorage_2eproto__INCLUDED
  #define PROTOBUF_dictionary_2fuser_5fdictionary_5fstorage_2eproto__INCLUDED
  
  #include <string>
  
  #include <google/protobuf/stubs/common.h>
  
  #if GOOGLE_PROTOBUF_VERSION < 2005001
  #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 2005001 < 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/message.h>
  #include <google/protobuf/repeated_field.h>
  #include <google/protobuf/extension_set.h>
  #include <google/protobuf/generated_enum_reflection.h>
  #include <google/protobuf/unknown_field_set.h>
  // @@protoc_insertion_point(includes)
  
  namespace mozc {
  namespace user_dictionary {
  
  // Internal implementation detail -- do not call these.
  void  protobuf_AddDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
  void protobuf_AssignDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
  void protobuf_ShutdownFile_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
  
  class UserDictionary;
  class UserDictionary_Entry;
  class UserDictionaryStorage;
  class UserDictionaryCommand;
  class UserDictionaryCommandStatus;
  
  enum UserDictionary_PosType {
    UserDictionary_PosType_NOUN = 1,
    UserDictionary_PosType_ABBREVIATION = 2,
    UserDictionary_PosType_SUGGESTION_ONLY = 3,
    UserDictionary_PosType_PROPER_NOUN = 4,
    UserDictionary_PosType_PERSONAL_NAME = 5,
    UserDictionary_PosType_FAMILY_NAME = 6,
    UserDictionary_PosType_FIRST_NAME = 7,
    UserDictionary_PosType_ORGANIZATION_NAME = 8,
    UserDictionary_PosType_PLACE_NAME = 9,
    UserDictionary_PosType_SA_IRREGULAR_CONJUGATION_NOUN = 10,
    UserDictionary_PosType_ADJECTIVE_VERBAL_NOUN = 11,
    UserDictionary_PosType_NUMBER = 12,
    UserDictionary_PosType_ALPHABET = 13,
    UserDictionary_PosType_SYMBOL = 14,
    UserDictionary_PosType_EMOTICON = 15,
    UserDictionary_PosType_ADVERB = 16,
    UserDictionary_PosType_PRENOUN_ADJECTIVAL = 17,
    UserDictionary_PosType_CONJUNCTION = 18,
    UserDictionary_PosType_INTERJECTION = 19,
    UserDictionary_PosType_PREFIX = 20,
    UserDictionary_PosType_COUNTER_SUFFIX = 21,
    UserDictionary_PosType_GENERIC_SUFFIX = 22,
    UserDictionary_PosType_PERSON_NAME_SUFFIX = 23,
    UserDictionary_PosType_PLACE_NAME_SUFFIX = 24,
    UserDictionary_PosType_WA_GROUP1_VERB = 25,
    UserDictionary_PosType_KA_GROUP1_VERB = 26,
    UserDictionary_PosType_SA_GROUP1_VERB = 27,
    UserDictionary_PosType_TA_GROUP1_VERB = 28,
    UserDictionary_PosType_NA_GROUP1_VERB = 29,
    UserDictionary_PosType_MA_GROUP1_VERB = 30,
    UserDictionary_PosType_RA_GROUP1_VERB = 31,
    UserDictionary_PosType_GA_GROUP1_VERB = 32,
    UserDictionary_PosType_BA_GROUP1_VERB = 33,
    UserDictionary_PosType_HA_GROUP1_VERB = 34,
    UserDictionary_PosType_GROUP2_VERB = 35,
    UserDictionary_PosType_KURU_GROUP3_VERB = 36,
    UserDictionary_PosType_SURU_GROUP3_VERB = 37,
    UserDictionary_PosType_ZURU_GROUP3_VERB = 38,
    UserDictionary_PosType_RU_GROUP3_VERB = 39,
    UserDictionary_PosType_ADJECTIVE = 40,
    UserDictionary_PosType_SENTENCE_ENDING_PARTICLE = 41,
    UserDictionary_PosType_PUNCTUATION = 42,
    UserDictionary_PosType_FREE_STANDING_WORD = 43,
    UserDictionary_PosType_SUPPRESSION_WORD = 44
  };
  bool UserDictionary_PosType_IsValid(int value);
  const UserDictionary_PosType UserDictionary_PosType_PosType_MIN = UserDictionary_PosType_NOUN;
  const UserDictionary_PosType UserDictionary_PosType_PosType_MAX = UserDictionary_PosType_SUPPRESSION_WORD;
  const int UserDictionary_PosType_PosType_ARRAYSIZE = UserDictionary_PosType_PosType_MAX + 1;
  
  const ::google::protobuf::EnumDescriptor* UserDictionary_PosType_descriptor();
  inline const ::std::string& UserDictionary_PosType_Name(UserDictionary_PosType value) {
    return ::google::protobuf::internal::NameOfEnum(
      UserDictionary_PosType_descriptor(), value);
  }
  inline bool UserDictionary_PosType_Parse(
      const ::std::string& name, UserDictionary_PosType* value) {
    return ::google::protobuf::internal::ParseNamedEnum<UserDictionary_PosType>(
      UserDictionary_PosType_descriptor(), name, value);
  }
  enum UserDictionaryStorage_StorageType {
    UserDictionaryStorage_StorageType_SNAPSHOT = 1,
    UserDictionaryStorage_StorageType_UPDATE = 2
  };
  bool UserDictionaryStorage_StorageType_IsValid(int value);
  const UserDictionaryStorage_StorageType UserDictionaryStorage_StorageType_StorageType_MIN = UserDictionaryStorage_StorageType_SNAPSHOT;
  const UserDictionaryStorage_StorageType UserDictionaryStorage_StorageType_StorageType_MAX = UserDictionaryStorage_StorageType_UPDATE;
  const int UserDictionaryStorage_StorageType_StorageType_ARRAYSIZE = UserDictionaryStorage_StorageType_StorageType_MAX + 1;
  
  const ::google::protobuf::EnumDescriptor* UserDictionaryStorage_StorageType_descriptor();
  inline const ::std::string& UserDictionaryStorage_StorageType_Name(UserDictionaryStorage_StorageType value) {
    return ::google::protobuf::internal::NameOfEnum(
      UserDictionaryStorage_StorageType_descriptor(), value);
  }
  inline bool UserDictionaryStorage_StorageType_Parse(
      const ::std::string& name, UserDictionaryStorage_StorageType* value) {
    return ::google::protobuf::internal::ParseNamedEnum<UserDictionaryStorage_StorageType>(
      UserDictionaryStorage_StorageType_descriptor(), name, value);
  }
  enum UserDictionaryCommand_CommandType {
    UserDictionaryCommand_CommandType_NO_OPERATION = 0,
    UserDictionaryCommand_CommandType_CLEAR_STORAGE = 1,
    UserDictionaryCommand_CommandType_CREATE_SESSION = 2,
    UserDictionaryCommand_CommandType_DELETE_SESSION = 3,
    UserDictionaryCommand_CommandType_SET_DEFAULT_DICTIONARY_NAME = 4,
    UserDictionaryCommand_CommandType_CHECK_UNDOABILITY = 5,
    UserDictionaryCommand_CommandType_UNDO = 6,
    UserDictionaryCommand_CommandType_LOAD = 7,
    UserDictionaryCommand_CommandType_SAVE = 8,
    UserDictionaryCommand_CommandType_GET_USER_DICTIONARY_NAME_LIST = 9,
    UserDictionaryCommand_CommandType_GET_ENTRY_SIZE = 10,
    UserDictionaryCommand_CommandType_OBSOLETE_GET_ENTRY = 11,
    UserDictionaryCommand_CommandType_CHECK_NEW_DICTIONARY_AVAILABILITY = 12,
    UserDictionaryCommand_CommandType_CREATE_DICTIONARY = 13,
    UserDictionaryCommand_CommandType_DELETE_DICTIONARY = 14,
    UserDictionaryCommand_CommandType_RENAME_DICTIONARY = 15,
    UserDictionaryCommand_CommandType_CHECK_NEW_ENTRY_AVAILABILITY = 16,
    UserDictionaryCommand_CommandType_ADD_ENTRY = 17,
    UserDictionaryCommand_CommandType_EDIT_ENTRY = 18,
    UserDictionaryCommand_CommandType_DELETE_ENTRY = 19,
    UserDictionaryCommand_CommandType_IMPORT_DATA = 20,
    UserDictionaryCommand_CommandType_GET_STORAGE = 21,
    UserDictionaryCommand_CommandType_GET_ENTRIES = 22
  };
  bool UserDictionaryCommand_CommandType_IsValid(int value);
  const UserDictionaryCommand_CommandType UserDictionaryCommand_CommandType_CommandType_MIN = UserDictionaryCommand_CommandType_NO_OPERATION;
  const UserDictionaryCommand_CommandType UserDictionaryCommand_CommandType_CommandType_MAX = UserDictionaryCommand_CommandType_GET_ENTRIES;
  const int UserDictionaryCommand_CommandType_CommandType_ARRAYSIZE = UserDictionaryCommand_CommandType_CommandType_MAX + 1;
  
  const ::google::protobuf::EnumDescriptor* UserDictionaryCommand_CommandType_descriptor();
  inline const ::std::string& UserDictionaryCommand_CommandType_Name(UserDictionaryCommand_CommandType value) {
    return ::google::protobuf::internal::NameOfEnum(
      UserDictionaryCommand_CommandType_descriptor(), value);
  }
  inline bool UserDictionaryCommand_CommandType_Parse(
      const ::std::string& name, UserDictionaryCommand_CommandType* value) {
    return ::google::protobuf::internal::ParseNamedEnum<UserDictionaryCommand_CommandType>(
      UserDictionaryCommand_CommandType_descriptor(), name, value);
  }
  enum UserDictionaryCommandStatus_Status {
    UserDictionaryCommandStatus_Status_USER_DICTIONARY_COMMAND_SUCCESS = 1,
    UserDictionaryCommandStatus_Status_UNKNOWN_ERROR = 2,
    UserDictionaryCommandStatus_Status_UNKNOWN_COMMAND = 3,
    UserDictionaryCommandStatus_Status_INVALID_ARGUMENT = 4,
    UserDictionaryCommandStatus_Status_UNKNOWN_SESSION_ID = 5,
    UserDictionaryCommandStatus_Status_FILE_NOT_FOUND = 6,
    UserDictionaryCommandStatus_Status_INVALID_FILE_FORMAT = 7,
    UserDictionaryCommandStatus_Status_FILE_SIZE_LIMIT_EXCEEDED = 8,
    UserDictionaryCommandStatus_Status_DICTIONARY_SIZE_LIMIT_EXCEEDED = 9,
    UserDictionaryCommandStatus_Status_ENTRY_SIZE_LIMIT_EXCEEDED = 10,
    UserDictionaryCommandStatus_Status_UNKNOWN_DICTIONARY_ID = 11,
    UserDictionaryCommandStatus_Status_ENTRY_INDEX_OUT_OF_RANGE = 12,
    UserDictionaryCommandStatus_Status_DICTIONARY_NAME_EMPTY = 13,
    UserDictionaryCommandStatus_Status_DICTIONARY_NAME_TOO_LONG = 14,
    UserDictionaryCommandStatus_Status_DICTIONARY_NAME_CONTAINS_INVALID_CHARACTER = 15,
    UserDictionaryCommandStatus_Status_DICTIONARY_NAME_DUPLICATED = 16,
    UserDictionaryCommandStatus_Status_READING_EMPTY = 17,
    UserDictionaryCommandStatus_Status_READING_TOO_LONG = 18,
    UserDictionaryCommandStatus_Status_READING_CONTAINS_INVALID_CHARACTER = 19,
    UserDictionaryCommandStatus_Status_WORD_EMPTY = 20,
    UserDictionaryCommandStatus_Status_WORD_TOO_LONG = 21,
    UserDictionaryCommandStatus_Status_WORD_CONTAINS_INVALID_CHARACTER = 22,
    UserDictionaryCommandStatus_Status_INVALID_POS_TYPE = 23,
    UserDictionaryCommandStatus_Status_COMMENT_TOO_LONG = 24,
    UserDictionaryCommandStatus_Status_COMMENT_CONTAINS_INVALID_CHARACTER = 25,
    UserDictionaryCommandStatus_Status_IMPORT_TOO_MANY_WORDS = 26,
    UserDictionaryCommandStatus_Status_IMPORT_INVALID_ENTRIES = 27,
    UserDictionaryCommandStatus_Status_NO_UNDO_HISTORY = 28
  };
  bool UserDictionaryCommandStatus_Status_IsValid(int value);
  const UserDictionaryCommandStatus_Status UserDictionaryCommandStatus_Status_Status_MIN = UserDictionaryCommandStatus_Status_USER_DICTIONARY_COMMAND_SUCCESS;
  const UserDictionaryCommandStatus_Status UserDictionaryCommandStatus_Status_Status_MAX = UserDictionaryCommandStatus_Status_NO_UNDO_HISTORY;
  const int UserDictionaryCommandStatus_Status_Status_ARRAYSIZE = UserDictionaryCommandStatus_Status_Status_MAX + 1;
  
  const ::google::protobuf::EnumDescriptor* UserDictionaryCommandStatus_Status_descriptor();
  inline const ::std::string& UserDictionaryCommandStatus_Status_Name(UserDictionaryCommandStatus_Status value) {
    return ::google::protobuf::internal::NameOfEnum(
      UserDictionaryCommandStatus_Status_descriptor(), value);
  }
  inline bool UserDictionaryCommandStatus_Status_Parse(
      const ::std::string& name, UserDictionaryCommandStatus_Status* value) {
    return ::google::protobuf::internal::ParseNamedEnum<UserDictionaryCommandStatus_Status>(
      UserDictionaryCommandStatus_Status_descriptor(), name, value);
  }
  // ===================================================================
  
  class UserDictionary_Entry : public ::google::protobuf::Message {
   public:
    UserDictionary_Entry();
    virtual ~UserDictionary_Entry();
  
    UserDictionary_Entry(const UserDictionary_Entry& from);
  
    inline UserDictionary_Entry& operator=(const UserDictionary_Entry& from) {
      CopyFrom(from);
      return *this;
    }
  
    inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
      return _unknown_fields_;
    }
  
    inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
      return &_unknown_fields_;
    }
  
    static const ::google::protobuf::Descriptor* descriptor();
    static const UserDictionary_Entry& default_instance();
  
    void Swap(UserDictionary_Entry* other);
  
    // implements Message ----------------------------------------------
  
    UserDictionary_Entry* New() const;
    void CopyFrom(const ::google::protobuf::Message& from);
    void MergeFrom(const ::google::protobuf::Message& from);
    void CopyFrom(const UserDictionary_Entry& from);
    void MergeFrom(const UserDictionary_Entry& from);
    void Clear();
    bool IsInitialized() const;
  
    int ByteSize() const;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input);
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const;
    ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
    int GetCachedSize() const { return _cached_size_; }
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const;
    public:
  
    ::google::protobuf::Metadata GetMetadata() const;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    // optional string key = 1 [default = ""];
    inline bool has_key() const;
    inline void clear_key();
    static const int kKeyFieldNumber = 1;
    inline const ::std::string& key() const;
    inline void set_key(const ::std::string& value);
    inline void set_key(const char* value);
    inline void set_key(const char* value, size_t size);
    inline ::std::string* mutable_key();
    inline ::std::string* release_key();
    inline void set_allocated_key(::std::string* key);
  
    // optional string value = 2 [default = ""];
    inline bool has_value() const;
    inline void clear_value();
    static const int kValueFieldNumber = 2;
    inline const ::std::string& value() const;
    inline void set_value(const ::std::string& value);
    inline void set_value(const char* value);
    inline void set_value(const char* value, size_t size);
    inline ::std::string* mutable_value();
    inline ::std::string* release_value();
    inline void set_allocated_value(::std::string* value);
  
    // optional string comment = 4 [default = ""];
    inline bool has_comment() const;
    inline void clear_comment();
    static const int kCommentFieldNumber = 4;
    inline const ::std::string& comment() const;
    inline void set_comment(const ::std::string& value);
    inline void set_comment(const char* value);
    inline void set_comment(const char* value, size_t size);
    inline ::std::string* mutable_comment();
    inline ::std::string* release_comment();
    inline void set_allocated_comment(::std::string* comment);
  
    // optional .mozc.user_dictionary.UserDictionary.PosType pos = 5;
    inline bool has_pos() const;
    inline void clear_pos();
    static const int kPosFieldNumber = 5;
    inline ::mozc::user_dictionary::UserDictionary_PosType pos() const;
    inline void set_pos(::mozc::user_dictionary::UserDictionary_PosType value);
  
    // optional bool removed = 10 [default = false];
    inline bool has_removed() const;
    inline void clear_removed();
    static const int kRemovedFieldNumber = 10;
    inline bool removed() const;
    inline void set_removed(bool value);
  
    // optional bool auto_registered = 11 [default = false];
    inline bool has_auto_registered() const;
    inline void clear_auto_registered();
    static const int kAutoRegisteredFieldNumber = 11;
    inline bool auto_registered() const;
    inline void set_auto_registered(bool value);
  
    // @@protoc_insertion_point(class_scope:mozc.user_dictionary.UserDictionary.Entry)
   private:
    inline void set_has_key();
    inline void clear_has_key();
    inline void set_has_value();
    inline void clear_has_value();
    inline void set_has_comment();
    inline void clear_has_comment();
    inline void set_has_pos();
    inline void clear_has_pos();
    inline void set_has_removed();
    inline void clear_has_removed();
    inline void set_has_auto_registered();
    inline void clear_has_auto_registered();
  
    ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
    ::std::string* key_;
    ::std::string* value_;
    ::std::string* comment_;
    int pos_;
    bool removed_;
    bool auto_registered_;
  
    mutable int _cached_size_;
    ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
  
    friend void  protobuf_AddDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_AssignDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_ShutdownFile_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
  
    void InitAsDefaultInstance();
    static UserDictionary_Entry* default_instance_;
  };
  // -------------------------------------------------------------------
  
  class UserDictionary : public ::google::protobuf::Message {
   public:
    UserDictionary();
    virtual ~UserDictionary();
  
    UserDictionary(const UserDictionary& from);
  
    inline UserDictionary& operator=(const UserDictionary& from) {
      CopyFrom(from);
      return *this;
    }
  
    inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
      return _unknown_fields_;
    }
  
    inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
      return &_unknown_fields_;
    }
  
    static const ::google::protobuf::Descriptor* descriptor();
    static const UserDictionary& default_instance();
  
    void Swap(UserDictionary* other);
  
    // implements Message ----------------------------------------------
  
    UserDictionary* New() const;
    void CopyFrom(const ::google::protobuf::Message& from);
    void MergeFrom(const ::google::protobuf::Message& from);
    void CopyFrom(const UserDictionary& from);
    void MergeFrom(const UserDictionary& from);
    void Clear();
    bool IsInitialized() const;
  
    int ByteSize() const;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input);
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const;
    ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
    int GetCachedSize() const { return _cached_size_; }
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const;
    public:
  
    ::google::protobuf::Metadata GetMetadata() const;
  
    // nested types ----------------------------------------------------
  
    typedef UserDictionary_Entry Entry;
  
    typedef UserDictionary_PosType PosType;
    static const PosType NOUN = UserDictionary_PosType_NOUN;
    static const PosType ABBREVIATION = UserDictionary_PosType_ABBREVIATION;
    static const PosType SUGGESTION_ONLY = UserDictionary_PosType_SUGGESTION_ONLY;
    static const PosType PROPER_NOUN = UserDictionary_PosType_PROPER_NOUN;
    static const PosType PERSONAL_NAME = UserDictionary_PosType_PERSONAL_NAME;
    static const PosType FAMILY_NAME = UserDictionary_PosType_FAMILY_NAME;
    static const PosType FIRST_NAME = UserDictionary_PosType_FIRST_NAME;
    static const PosType ORGANIZATION_NAME = UserDictionary_PosType_ORGANIZATION_NAME;
    static const PosType PLACE_NAME = UserDictionary_PosType_PLACE_NAME;
    static const PosType SA_IRREGULAR_CONJUGATION_NOUN = UserDictionary_PosType_SA_IRREGULAR_CONJUGATION_NOUN;
    static const PosType ADJECTIVE_VERBAL_NOUN = UserDictionary_PosType_ADJECTIVE_VERBAL_NOUN;
    static const PosType NUMBER = UserDictionary_PosType_NUMBER;
    static const PosType ALPHABET = UserDictionary_PosType_ALPHABET;
    static const PosType SYMBOL = UserDictionary_PosType_SYMBOL;
    static const PosType EMOTICON = UserDictionary_PosType_EMOTICON;
    static const PosType ADVERB = UserDictionary_PosType_ADVERB;
    static const PosType PRENOUN_ADJECTIVAL = UserDictionary_PosType_PRENOUN_ADJECTIVAL;
    static const PosType CONJUNCTION = UserDictionary_PosType_CONJUNCTION;
    static const PosType INTERJECTION = UserDictionary_PosType_INTERJECTION;
    static const PosType PREFIX = UserDictionary_PosType_PREFIX;
    static const PosType COUNTER_SUFFIX = UserDictionary_PosType_COUNTER_SUFFIX;
    static const PosType GENERIC_SUFFIX = UserDictionary_PosType_GENERIC_SUFFIX;
    static const PosType PERSON_NAME_SUFFIX = UserDictionary_PosType_PERSON_NAME_SUFFIX;
    static const PosType PLACE_NAME_SUFFIX = UserDictionary_PosType_PLACE_NAME_SUFFIX;
    static const PosType WA_GROUP1_VERB = UserDictionary_PosType_WA_GROUP1_VERB;
    static const PosType KA_GROUP1_VERB = UserDictionary_PosType_KA_GROUP1_VERB;
    static const PosType SA_GROUP1_VERB = UserDictionary_PosType_SA_GROUP1_VERB;
    static const PosType TA_GROUP1_VERB = UserDictionary_PosType_TA_GROUP1_VERB;
    static const PosType NA_GROUP1_VERB = UserDictionary_PosType_NA_GROUP1_VERB;
    static const PosType MA_GROUP1_VERB = UserDictionary_PosType_MA_GROUP1_VERB;
    static const PosType RA_GROUP1_VERB = UserDictionary_PosType_RA_GROUP1_VERB;
    static const PosType GA_GROUP1_VERB = UserDictionary_PosType_GA_GROUP1_VERB;
    static const PosType BA_GROUP1_VERB = UserDictionary_PosType_BA_GROUP1_VERB;
    static const PosType HA_GROUP1_VERB = UserDictionary_PosType_HA_GROUP1_VERB;
    static const PosType GROUP2_VERB = UserDictionary_PosType_GROUP2_VERB;
    static const PosType KURU_GROUP3_VERB = UserDictionary_PosType_KURU_GROUP3_VERB;
    static const PosType SURU_GROUP3_VERB = UserDictionary_PosType_SURU_GROUP3_VERB;
    static const PosType ZURU_GROUP3_VERB = UserDictionary_PosType_ZURU_GROUP3_VERB;
    static const PosType RU_GROUP3_VERB = UserDictionary_PosType_RU_GROUP3_VERB;
    static const PosType ADJECTIVE = UserDictionary_PosType_ADJECTIVE;
    static const PosType SENTENCE_ENDING_PARTICLE = UserDictionary_PosType_SENTENCE_ENDING_PARTICLE;
    static const PosType PUNCTUATION = UserDictionary_PosType_PUNCTUATION;
    static const PosType FREE_STANDING_WORD = UserDictionary_PosType_FREE_STANDING_WORD;
    static const PosType SUPPRESSION_WORD = UserDictionary_PosType_SUPPRESSION_WORD;
    static inline bool PosType_IsValid(int value) {
      return UserDictionary_PosType_IsValid(value);
    }
    static const PosType PosType_MIN =
      UserDictionary_PosType_PosType_MIN;
    static const PosType PosType_MAX =
      UserDictionary_PosType_PosType_MAX;
    static const int PosType_ARRAYSIZE =
      UserDictionary_PosType_PosType_ARRAYSIZE;
    static inline const ::google::protobuf::EnumDescriptor*
    PosType_descriptor() {
      return UserDictionary_PosType_descriptor();
    }
    static inline const ::std::string& PosType_Name(PosType value) {
      return UserDictionary_PosType_Name(value);
    }
    static inline bool PosType_Parse(const ::std::string& name,
        PosType* value) {
      return UserDictionary_PosType_Parse(name, value);
    }
  
    // accessors -------------------------------------------------------
  
    // optional uint64 id = 1 [default = 0];
    inline bool has_id() const;
    inline void clear_id();
    static const int kIdFieldNumber = 1;
    inline ::google::protobuf::uint64 id() const;
    inline void set_id(::google::protobuf::uint64 value);
  
    // optional bool enabled = 2 [default = true];
    inline bool has_enabled() const;
    inline void clear_enabled();
    static const int kEnabledFieldNumber = 2;
    inline bool enabled() const;
    inline void set_enabled(bool value);
  
    // optional string name = 3 [default = ""];
    inline bool has_name() const;
    inline void clear_name();
    static const int kNameFieldNumber = 3;
    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();
    inline void set_allocated_name(::std::string* name);
  
    // repeated .mozc.user_dictionary.UserDictionary.Entry entries = 4;
    inline int entries_size() const;
    inline void clear_entries();
    static const int kEntriesFieldNumber = 4;
    inline const ::mozc::user_dictionary::UserDictionary_Entry& entries(int index) const;
    inline ::mozc::user_dictionary::UserDictionary_Entry* mutable_entries(int index);
    inline ::mozc::user_dictionary::UserDictionary_Entry* add_entries();
    inline const ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry >&
        entries() const;
    inline ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry >*
        mutable_entries();
  
    // optional bool removed = 5 [default = false];
    inline bool has_removed() const;
    inline void clear_removed();
    static const int kRemovedFieldNumber = 5;
    inline bool removed() const;
    inline void set_removed(bool value);
  
    // optional bool syncable = 6 [default = false];
    inline bool has_syncable() const;
    inline void clear_syncable();
    static const int kSyncableFieldNumber = 6;
    inline bool syncable() const;
    inline void set_syncable(bool value);
  
    // @@protoc_insertion_point(class_scope:mozc.user_dictionary.UserDictionary)
   private:
    inline void set_has_id();
    inline void clear_has_id();
    inline void set_has_enabled();
    inline void clear_has_enabled();
    inline void set_has_name();
    inline void clear_has_name();
    inline void set_has_removed();
    inline void clear_has_removed();
    inline void set_has_syncable();
    inline void clear_has_syncable();
  
    ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
    ::google::protobuf::uint64 id_;
    ::std::string* name_;
    ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry > entries_;
    bool enabled_;
    bool removed_;
    bool syncable_;
  
    mutable int _cached_size_;
    ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
  
    friend void  protobuf_AddDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_AssignDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_ShutdownFile_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
  
    void InitAsDefaultInstance();
    static UserDictionary* default_instance_;
  };
  // -------------------------------------------------------------------
  
  class UserDictionaryStorage : public ::google::protobuf::Message {
   public:
    UserDictionaryStorage();
    virtual ~UserDictionaryStorage();
  
    UserDictionaryStorage(const UserDictionaryStorage& from);
  
    inline UserDictionaryStorage& operator=(const UserDictionaryStorage& from) {
      CopyFrom(from);
      return *this;
    }
  
    inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
      return _unknown_fields_;
    }
  
    inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
      return &_unknown_fields_;
    }
  
    static const ::google::protobuf::Descriptor* descriptor();
    static const UserDictionaryStorage& default_instance();
  
    void Swap(UserDictionaryStorage* other);
  
    // implements Message ----------------------------------------------
  
    UserDictionaryStorage* New() const;
    void CopyFrom(const ::google::protobuf::Message& from);
    void MergeFrom(const ::google::protobuf::Message& from);
    void CopyFrom(const UserDictionaryStorage& from);
    void MergeFrom(const UserDictionaryStorage& from);
    void Clear();
    bool IsInitialized() const;
  
    int ByteSize() const;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input);
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const;
    ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
    int GetCachedSize() const { return _cached_size_; }
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const;
    public:
  
    ::google::protobuf::Metadata GetMetadata() const;
  
    // nested types ----------------------------------------------------
  
    typedef UserDictionaryStorage_StorageType StorageType;
    static const StorageType SNAPSHOT = UserDictionaryStorage_StorageType_SNAPSHOT;
    static const StorageType UPDATE = UserDictionaryStorage_StorageType_UPDATE;
    static inline bool StorageType_IsValid(int value) {
      return UserDictionaryStorage_StorageType_IsValid(value);
    }
    static const StorageType StorageType_MIN =
      UserDictionaryStorage_StorageType_StorageType_MIN;
    static const StorageType StorageType_MAX =
      UserDictionaryStorage_StorageType_StorageType_MAX;
    static const int StorageType_ARRAYSIZE =
      UserDictionaryStorage_StorageType_StorageType_ARRAYSIZE;
    static inline const ::google::protobuf::EnumDescriptor*
    StorageType_descriptor() {
      return UserDictionaryStorage_StorageType_descriptor();
    }
    static inline const ::std::string& StorageType_Name(StorageType value) {
      return UserDictionaryStorage_StorageType_Name(value);
    }
    static inline bool StorageType_Parse(const ::std::string& name,
        StorageType* value) {
      return UserDictionaryStorage_StorageType_Parse(name, value);
    }
  
    // accessors -------------------------------------------------------
  
    // optional int32 version = 1 [default = 0];
    inline bool has_version() const;
    inline void clear_version();
    static const int kVersionFieldNumber = 1;
    inline ::google::protobuf::int32 version() const;
    inline void set_version(::google::protobuf::int32 value);
  
    // repeated .mozc.user_dictionary.UserDictionary dictionaries = 2;
    inline int dictionaries_size() const;
    inline void clear_dictionaries();
    static const int kDictionariesFieldNumber = 2;
    inline const ::mozc::user_dictionary::UserDictionary& dictionaries(int index) const;
    inline ::mozc::user_dictionary::UserDictionary* mutable_dictionaries(int index);
    inline ::mozc::user_dictionary::UserDictionary* add_dictionaries();
    inline const ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary >&
        dictionaries() const;
    inline ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary >*
        mutable_dictionaries();
  
    // optional .mozc.user_dictionary.UserDictionaryStorage.StorageType storage_type = 10 [default = SNAPSHOT];
    inline bool has_storage_type() const;
    inline void clear_storage_type();
    static const int kStorageTypeFieldNumber = 10;
    inline ::mozc::user_dictionary::UserDictionaryStorage_StorageType storage_type() const;
    inline void set_storage_type(::mozc::user_dictionary::UserDictionaryStorage_StorageType value);
  
    // @@protoc_insertion_point(class_scope:mozc.user_dictionary.UserDictionaryStorage)
   private:
    inline void set_has_version();
    inline void clear_has_version();
    inline void set_has_storage_type();
    inline void clear_has_storage_type();
  
    ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
    ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary > dictionaries_;
    ::google::protobuf::int32 version_;
    int storage_type_;
  
    mutable int _cached_size_;
    ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
    friend void  protobuf_AddDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_AssignDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_ShutdownFile_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
  
    void InitAsDefaultInstance();
    static UserDictionaryStorage* default_instance_;
  };
  // -------------------------------------------------------------------
  
  class UserDictionaryCommand : public ::google::protobuf::Message {
   public:
    UserDictionaryCommand();
    virtual ~UserDictionaryCommand();
  
    UserDictionaryCommand(const UserDictionaryCommand& from);
  
    inline UserDictionaryCommand& operator=(const UserDictionaryCommand& from) {
      CopyFrom(from);
      return *this;
    }
  
    inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
      return _unknown_fields_;
    }
  
    inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
      return &_unknown_fields_;
    }
  
    static const ::google::protobuf::Descriptor* descriptor();
    static const UserDictionaryCommand& default_instance();
  
    void Swap(UserDictionaryCommand* other);
  
    // implements Message ----------------------------------------------
  
    UserDictionaryCommand* New() const;
    void CopyFrom(const ::google::protobuf::Message& from);
    void MergeFrom(const ::google::protobuf::Message& from);
    void CopyFrom(const UserDictionaryCommand& from);
    void MergeFrom(const UserDictionaryCommand& from);
    void Clear();
    bool IsInitialized() const;
  
    int ByteSize() const;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input);
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const;
    ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
    int GetCachedSize() const { return _cached_size_; }
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const;
    public:
  
    ::google::protobuf::Metadata GetMetadata() const;
  
    // nested types ----------------------------------------------------
  
    typedef UserDictionaryCommand_CommandType CommandType;
    static const CommandType NO_OPERATION = UserDictionaryCommand_CommandType_NO_OPERATION;
    static const CommandType CLEAR_STORAGE = UserDictionaryCommand_CommandType_CLEAR_STORAGE;
    static const CommandType CREATE_SESSION = UserDictionaryCommand_CommandType_CREATE_SESSION;
    static const CommandType DELETE_SESSION = UserDictionaryCommand_CommandType_DELETE_SESSION;
    static const CommandType SET_DEFAULT_DICTIONARY_NAME = UserDictionaryCommand_CommandType_SET_DEFAULT_DICTIONARY_NAME;
    static const CommandType CHECK_UNDOABILITY = UserDictionaryCommand_CommandType_CHECK_UNDOABILITY;
    static const CommandType UNDO = UserDictionaryCommand_CommandType_UNDO;
    static const CommandType LOAD = UserDictionaryCommand_CommandType_LOAD;
    static const CommandType SAVE = UserDictionaryCommand_CommandType_SAVE;
    static const CommandType GET_USER_DICTIONARY_NAME_LIST = UserDictionaryCommand_CommandType_GET_USER_DICTIONARY_NAME_LIST;
    static const CommandType GET_ENTRY_SIZE = UserDictionaryCommand_CommandType_GET_ENTRY_SIZE;
    static const CommandType OBSOLETE_GET_ENTRY = UserDictionaryCommand_CommandType_OBSOLETE_GET_ENTRY;
    static const CommandType CHECK_NEW_DICTIONARY_AVAILABILITY = UserDictionaryCommand_CommandType_CHECK_NEW_DICTIONARY_AVAILABILITY;
    static const CommandType CREATE_DICTIONARY = UserDictionaryCommand_CommandType_CREATE_DICTIONARY;
    static const CommandType DELETE_DICTIONARY = UserDictionaryCommand_CommandType_DELETE_DICTIONARY;
    static const CommandType RENAME_DICTIONARY = UserDictionaryCommand_CommandType_RENAME_DICTIONARY;
    static const CommandType CHECK_NEW_ENTRY_AVAILABILITY = UserDictionaryCommand_CommandType_CHECK_NEW_ENTRY_AVAILABILITY;
    static const CommandType ADD_ENTRY = UserDictionaryCommand_CommandType_ADD_ENTRY;
    static const CommandType EDIT_ENTRY = UserDictionaryCommand_CommandType_EDIT_ENTRY;
    static const CommandType DELETE_ENTRY = UserDictionaryCommand_CommandType_DELETE_ENTRY;
    static const CommandType IMPORT_DATA = UserDictionaryCommand_CommandType_IMPORT_DATA;
    static const CommandType GET_STORAGE = UserDictionaryCommand_CommandType_GET_STORAGE;
    static const CommandType GET_ENTRIES = UserDictionaryCommand_CommandType_GET_ENTRIES;
    static inline bool CommandType_IsValid(int value) {
      return UserDictionaryCommand_CommandType_IsValid(value);
    }
    static const CommandType CommandType_MIN =
      UserDictionaryCommand_CommandType_CommandType_MIN;
    static const CommandType CommandType_MAX =
      UserDictionaryCommand_CommandType_CommandType_MAX;
    static const int CommandType_ARRAYSIZE =
      UserDictionaryCommand_CommandType_CommandType_ARRAYSIZE;
    static inline const ::google::protobuf::EnumDescriptor*
    CommandType_descriptor() {
      return UserDictionaryCommand_CommandType_descriptor();
    }
    static inline const ::std::string& CommandType_Name(CommandType value) {
      return UserDictionaryCommand_CommandType_Name(value);
    }
    static inline bool CommandType_Parse(const ::std::string& name,
        CommandType* value) {
      return UserDictionaryCommand_CommandType_Parse(name, value);
    }
  
    // accessors -------------------------------------------------------
  
    // required .mozc.user_dictionary.UserDictionaryCommand.CommandType type = 1;
    inline bool has_type() const;
    inline void clear_type();
    static const int kTypeFieldNumber = 1;
    inline ::mozc::user_dictionary::UserDictionaryCommand_CommandType type() const;
    inline void set_type(::mozc::user_dictionary::UserDictionaryCommand_CommandType value);
  
    // optional uint64 session_id = 2;
    inline bool has_session_id() const;
    inline void clear_session_id();
    static const int kSessionIdFieldNumber = 2;
    inline ::google::protobuf::uint64 session_id() const;
    inline void set_session_id(::google::protobuf::uint64 value);
  
    // optional uint64 dictionary_id = 3;
    inline bool has_dictionary_id() const;
    inline void clear_dictionary_id();
    static const int kDictionaryIdFieldNumber = 3;
    inline ::google::protobuf::uint64 dictionary_id() const;
    inline void set_dictionary_id(::google::protobuf::uint64 value);
  
    // optional string dictionary_name = 4;
    inline bool has_dictionary_name() const;
    inline void clear_dictionary_name();
    static const int kDictionaryNameFieldNumber = 4;
    inline const ::std::string& dictionary_name() const;
    inline void set_dictionary_name(const ::std::string& value);
    inline void set_dictionary_name(const char* value);
    inline void set_dictionary_name(const char* value, size_t size);
    inline ::std::string* mutable_dictionary_name();
    inline ::std::string* release_dictionary_name();
    inline void set_allocated_dictionary_name(::std::string* dictionary_name);
  
    // repeated int32 entry_index = 5;
    inline int entry_index_size() const;
    inline void clear_entry_index();
    static const int kEntryIndexFieldNumber = 5;
    inline ::google::protobuf::int32 entry_index(int index) const;
    inline void set_entry_index(int index, ::google::protobuf::int32 value);
    inline void add_entry_index(::google::protobuf::int32 value);
    inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
        entry_index() const;
    inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
        mutable_entry_index();
  
    // optional .mozc.user_dictionary.UserDictionary.Entry entry = 6;
    inline bool has_entry() const;
    inline void clear_entry();
    static const int kEntryFieldNumber = 6;
    inline const ::mozc::user_dictionary::UserDictionary_Entry& entry() const;
    inline ::mozc::user_dictionary::UserDictionary_Entry* mutable_entry();
    inline ::mozc::user_dictionary::UserDictionary_Entry* release_entry();
    inline void set_allocated_entry(::mozc::user_dictionary::UserDictionary_Entry* entry);
  
    // optional string data = 7;
    inline bool has_data() const;
    inline void clear_data();
    static const int kDataFieldNumber = 7;
    inline const ::std::string& data() const;
    inline void set_data(const ::std::string& value);
    inline void set_data(const char* value);
    inline void set_data(const char* value, size_t size);
    inline ::std::string* mutable_data();
    inline ::std::string* release_data();
    inline void set_allocated_data(::std::string* data);
  
    // optional bool ensure_non_empty_storage = 8;
    inline bool has_ensure_non_empty_storage() const;
    inline void clear_ensure_non_empty_storage();
    static const int kEnsureNonEmptyStorageFieldNumber = 8;
    inline bool ensure_non_empty_storage() const;
    inline void set_ensure_non_empty_storage(bool value);
  
    // @@protoc_insertion_point(class_scope:mozc.user_dictionary.UserDictionaryCommand)
   private:
    inline void set_has_type();
    inline void clear_has_type();
    inline void set_has_session_id();
    inline void clear_has_session_id();
    inline void set_has_dictionary_id();
    inline void clear_has_dictionary_id();
    inline void set_has_dictionary_name();
    inline void clear_has_dictionary_name();
    inline void set_has_entry();
    inline void clear_has_entry();
    inline void set_has_data();
    inline void clear_has_data();
    inline void set_has_ensure_non_empty_storage();
    inline void clear_has_ensure_non_empty_storage();
  
    ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
    ::google::protobuf::uint64 session_id_;
    ::google::protobuf::uint64 dictionary_id_;
    ::std::string* dictionary_name_;
    int type_;
    bool ensure_non_empty_storage_;
    ::google::protobuf::RepeatedField< ::google::protobuf::int32 > entry_index_;
    ::mozc::user_dictionary::UserDictionary_Entry* entry_;
    ::std::string* data_;
  
    mutable int _cached_size_;
    ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
  
    friend void  protobuf_AddDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_AssignDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_ShutdownFile_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
  
    void InitAsDefaultInstance();
    static UserDictionaryCommand* default_instance_;
  };
  // -------------------------------------------------------------------
  
  class UserDictionaryCommandStatus : public ::google::protobuf::Message {
   public:
    UserDictionaryCommandStatus();
    virtual ~UserDictionaryCommandStatus();
  
    UserDictionaryCommandStatus(const UserDictionaryCommandStatus& from);
  
    inline UserDictionaryCommandStatus& operator=(const UserDictionaryCommandStatus& from) {
      CopyFrom(from);
      return *this;
    }
  
    inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
      return _unknown_fields_;
    }
  
    inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
      return &_unknown_fields_;
    }
  
    static const ::google::protobuf::Descriptor* descriptor();
    static const UserDictionaryCommandStatus& default_instance();
  
    void Swap(UserDictionaryCommandStatus* other);
  
    // implements Message ----------------------------------------------
  
    UserDictionaryCommandStatus* New() const;
    void CopyFrom(const ::google::protobuf::Message& from);
    void MergeFrom(const ::google::protobuf::Message& from);
    void CopyFrom(const UserDictionaryCommandStatus& from);
    void MergeFrom(const UserDictionaryCommandStatus& from);
    void Clear();
    bool IsInitialized() const;
  
    int ByteSize() const;
    bool MergePartialFromCodedStream(
        ::google::protobuf::io::CodedInputStream* input);
    void SerializeWithCachedSizes(
        ::google::protobuf::io::CodedOutputStream* output) const;
    ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
    int GetCachedSize() const { return _cached_size_; }
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const;
    public:
  
    ::google::protobuf::Metadata GetMetadata() const;
  
    // nested types ----------------------------------------------------
  
    typedef UserDictionaryCommandStatus_Status Status;
    static const Status USER_DICTIONARY_COMMAND_SUCCESS = UserDictionaryCommandStatus_Status_USER_DICTIONARY_COMMAND_SUCCESS;
    static const Status UNKNOWN_ERROR = UserDictionaryCommandStatus_Status_UNKNOWN_ERROR;
    static const Status UNKNOWN_COMMAND = UserDictionaryCommandStatus_Status_UNKNOWN_COMMAND;
    static const Status INVALID_ARGUMENT = UserDictionaryCommandStatus_Status_INVALID_ARGUMENT;
    static const Status UNKNOWN_SESSION_ID = UserDictionaryCommandStatus_Status_UNKNOWN_SESSION_ID;
    static const Status FILE_NOT_FOUND = UserDictionaryCommandStatus_Status_FILE_NOT_FOUND;
    static const Status INVALID_FILE_FORMAT = UserDictionaryCommandStatus_Status_INVALID_FILE_FORMAT;
    static const Status FILE_SIZE_LIMIT_EXCEEDED = UserDictionaryCommandStatus_Status_FILE_SIZE_LIMIT_EXCEEDED;
    static const Status DICTIONARY_SIZE_LIMIT_EXCEEDED = UserDictionaryCommandStatus_Status_DICTIONARY_SIZE_LIMIT_EXCEEDED;
    static const Status ENTRY_SIZE_LIMIT_EXCEEDED = UserDictionaryCommandStatus_Status_ENTRY_SIZE_LIMIT_EXCEEDED;
    static const Status UNKNOWN_DICTIONARY_ID = UserDictionaryCommandStatus_Status_UNKNOWN_DICTIONARY_ID;
    static const Status ENTRY_INDEX_OUT_OF_RANGE = UserDictionaryCommandStatus_Status_ENTRY_INDEX_OUT_OF_RANGE;
    static const Status DICTIONARY_NAME_EMPTY = UserDictionaryCommandStatus_Status_DICTIONARY_NAME_EMPTY;
    static const Status DICTIONARY_NAME_TOO_LONG = UserDictionaryCommandStatus_Status_DICTIONARY_NAME_TOO_LONG;
    static const Status DICTIONARY_NAME_CONTAINS_INVALID_CHARACTER = UserDictionaryCommandStatus_Status_DICTIONARY_NAME_CONTAINS_INVALID_CHARACTER;
    static const Status DICTIONARY_NAME_DUPLICATED = UserDictionaryCommandStatus_Status_DICTIONARY_NAME_DUPLICATED;
    static const Status READING_EMPTY = UserDictionaryCommandStatus_Status_READING_EMPTY;
    static const Status READING_TOO_LONG = UserDictionaryCommandStatus_Status_READING_TOO_LONG;
    static const Status READING_CONTAINS_INVALID_CHARACTER = UserDictionaryCommandStatus_Status_READING_CONTAINS_INVALID_CHARACTER;
    static const Status WORD_EMPTY = UserDictionaryCommandStatus_Status_WORD_EMPTY;
    static const Status WORD_TOO_LONG = UserDictionaryCommandStatus_Status_WORD_TOO_LONG;
    static const Status WORD_CONTAINS_INVALID_CHARACTER = UserDictionaryCommandStatus_Status_WORD_CONTAINS_INVALID_CHARACTER;
    static const Status INVALID_POS_TYPE = UserDictionaryCommandStatus_Status_INVALID_POS_TYPE;
    static const Status COMMENT_TOO_LONG = UserDictionaryCommandStatus_Status_COMMENT_TOO_LONG;
    static const Status COMMENT_CONTAINS_INVALID_CHARACTER = UserDictionaryCommandStatus_Status_COMMENT_CONTAINS_INVALID_CHARACTER;
    static const Status IMPORT_TOO_MANY_WORDS = UserDictionaryCommandStatus_Status_IMPORT_TOO_MANY_WORDS;
    static const Status IMPORT_INVALID_ENTRIES = UserDictionaryCommandStatus_Status_IMPORT_INVALID_ENTRIES;
    static const Status NO_UNDO_HISTORY = UserDictionaryCommandStatus_Status_NO_UNDO_HISTORY;
    static inline bool Status_IsValid(int value) {
      return UserDictionaryCommandStatus_Status_IsValid(value);
    }
    static const Status Status_MIN =
      UserDictionaryCommandStatus_Status_Status_MIN;
    static const Status Status_MAX =
      UserDictionaryCommandStatus_Status_Status_MAX;
    static const int Status_ARRAYSIZE =
      UserDictionaryCommandStatus_Status_Status_ARRAYSIZE;
    static inline const ::google::protobuf::EnumDescriptor*
    Status_descriptor() {
      return UserDictionaryCommandStatus_Status_descriptor();
    }
    static inline const ::std::string& Status_Name(Status value) {
      return UserDictionaryCommandStatus_Status_Name(value);
    }
    static inline bool Status_Parse(const ::std::string& name,
        Status* value) {
      return UserDictionaryCommandStatus_Status_Parse(name, value);
    }
  
    // accessors -------------------------------------------------------
  
    // required .mozc.user_dictionary.UserDictionaryCommandStatus.Status status = 1;
    inline bool has_status() const;
    inline void clear_status();
    static const int kStatusFieldNumber = 1;
    inline ::mozc::user_dictionary::UserDictionaryCommandStatus_Status status() const;
    inline void set_status(::mozc::user_dictionary::UserDictionaryCommandStatus_Status value);
  
    // optional uint64 session_id = 2;
    inline bool has_session_id() const;
    inline void clear_session_id();
    static const int kSessionIdFieldNumber = 2;
    inline ::google::protobuf::uint64 session_id() const;
    inline void set_session_id(::google::protobuf::uint64 value);
  
    // optional .mozc.user_dictionary.UserDictionaryStorage storage = 3;
    inline bool has_storage() const;
    inline void clear_storage();
    static const int kStorageFieldNumber = 3;
    inline const ::mozc::user_dictionary::UserDictionaryStorage& storage() const;
    inline ::mozc::user_dictionary::UserDictionaryStorage* mutable_storage();
    inline ::mozc::user_dictionary::UserDictionaryStorage* release_storage();
    inline void set_allocated_storage(::mozc::user_dictionary::UserDictionaryStorage* storage);
  
    // optional .mozc.user_dictionary.UserDictionary.Entry OBSOLETE_entry = 4;
    inline bool has_obsolete_entry() const;
    inline void clear_obsolete_entry();
    static const int kOBSOLETEEntryFieldNumber = 4;
    inline const ::mozc::user_dictionary::UserDictionary_Entry& obsolete_entry() const;
    inline ::mozc::user_dictionary::UserDictionary_Entry* mutable_obsolete_entry();
    inline ::mozc::user_dictionary::UserDictionary_Entry* release_obsolete_entry();
    inline void set_allocated_obsolete_entry(::mozc::user_dictionary::UserDictionary_Entry* obsolete_entry);
  
    // optional uint64 dictionary_id = 5;
    inline bool has_dictionary_id() const;
    inline void clear_dictionary_id();
    static const int kDictionaryIdFieldNumber = 5;
    inline ::google::protobuf::uint64 dictionary_id() const;
    inline void set_dictionary_id(::google::protobuf::uint64 value);
  
    // optional uint32 entry_size = 6;
    inline bool has_entry_size() const;
    inline void clear_entry_size();
    static const int kEntrySizeFieldNumber = 6;
    inline ::google::protobuf::uint32 entry_size() const;
    inline void set_entry_size(::google::protobuf::uint32 value);
  
    // repeated .mozc.user_dictionary.UserDictionary.Entry entries = 7;
    inline int entries_size() const;
    inline void clear_entries();
    static const int kEntriesFieldNumber = 7;
    inline const ::mozc::user_dictionary::UserDictionary_Entry& entries(int index) const;
    inline ::mozc::user_dictionary::UserDictionary_Entry* mutable_entries(int index);
    inline ::mozc::user_dictionary::UserDictionary_Entry* add_entries();
    inline const ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry >&
        entries() const;
    inline ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry >*
        mutable_entries();
  
    // @@protoc_insertion_point(class_scope:mozc.user_dictionary.UserDictionaryCommandStatus)
   private:
    inline void set_has_status();
    inline void clear_has_status();
    inline void set_has_session_id();
    inline void clear_has_session_id();
    inline void set_has_storage();
    inline void clear_has_storage();
    inline void set_has_obsolete_entry();
    inline void clear_has_obsolete_entry();
    inline void set_has_dictionary_id();
    inline void clear_has_dictionary_id();
    inline void set_has_entry_size();
    inline void clear_has_entry_size();
  
    ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
    ::google::protobuf::uint64 session_id_;
    ::mozc::user_dictionary::UserDictionaryStorage* storage_;
    int status_;
    ::google::protobuf::uint32 entry_size_;
    ::mozc::user_dictionary::UserDictionary_Entry* obsolete_entry_;
    ::google::protobuf::uint64 dictionary_id_;
    ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry > entries_;
  
    mutable int _cached_size_;
    ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
  
    friend void  protobuf_AddDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_AssignDesc_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
    friend void protobuf_ShutdownFile_dictionary_2fuser_5fdictionary_5fstorage_2eproto();
  
    void InitAsDefaultInstance();
    static UserDictionaryCommandStatus* default_instance_;
  };
  // ===================================================================
  
  
  // ===================================================================
  
  // UserDictionary_Entry
  
  // optional string key = 1 [default = ""];
  inline bool UserDictionary_Entry::has_key() const {
    return (_has_bits_[0] & 0x00000001u) != 0;
  }
  inline void UserDictionary_Entry::set_has_key() {
    _has_bits_[0] |= 0x00000001u;
  }
  inline void UserDictionary_Entry::clear_has_key() {
    _has_bits_[0] &= ~0x00000001u;
  }
  inline void UserDictionary_Entry::clear_key() {
    if (key_ != &::google::protobuf::internal::kEmptyString) {
      key_->clear();
    }
    clear_has_key();
  }
  inline const ::std::string& UserDictionary_Entry::key() const {
    return *key_;
  }
  inline void UserDictionary_Entry::set_key(const ::std::string& value) {
    set_has_key();
    if (key_ == &::google::protobuf::internal::kEmptyString) {
      key_ = new ::std::string;
    }
    key_->assign(value);
  }
  inline void UserDictionary_Entry::set_key(const char* value) {
    set_has_key();
    if (key_ == &::google::protobuf::internal::kEmptyString) {
      key_ = new ::std::string;
    }
    key_->assign(value);
  }
  inline void UserDictionary_Entry::set_key(const char* value, size_t size) {
    set_has_key();
    if (key_ == &::google::protobuf::internal::kEmptyString) {
      key_ = new ::std::string;
    }
    key_->assign(reinterpret_cast<const char*>(value), size);
  }
  inline ::std::string* UserDictionary_Entry::mutable_key() {
    set_has_key();
    if (key_ == &::google::protobuf::internal::kEmptyString) {
      key_ = new ::std::string;
    }
    return key_;
  }
  inline ::std::string* UserDictionary_Entry::release_key() {
    clear_has_key();
    if (key_ == &::google::protobuf::internal::kEmptyString) {
      return NULL;
    } else {
      ::std::string* temp = key_;
      key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
      return temp;
    }
  }
  inline void UserDictionary_Entry::set_allocated_key(::std::string* key) {
    if (key_ != &::google::protobuf::internal::kEmptyString) {
      delete key_;
    }
    if (key) {
      set_has_key();
      key_ = key;
    } else {
      clear_has_key();
      key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    }
  }
  
  // optional string value = 2 [default = ""];
  inline bool UserDictionary_Entry::has_value() const {
    return (_has_bits_[0] & 0x00000002u) != 0;
  }
  inline void UserDictionary_Entry::set_has_value() {
    _has_bits_[0] |= 0x00000002u;
  }
  inline void UserDictionary_Entry::clear_has_value() {
    _has_bits_[0] &= ~0x00000002u;
  }
  inline void UserDictionary_Entry::clear_value() {
    if (value_ != &::google::protobuf::internal::kEmptyString) {
      value_->clear();
    }
    clear_has_value();
  }
  inline const ::std::string& UserDictionary_Entry::value() const {
    return *value_;
  }
  inline void UserDictionary_Entry::set_value(const ::std::string& value) {
    set_has_value();
    if (value_ == &::google::protobuf::internal::kEmptyString) {
      value_ = new ::std::string;
    }
    value_->assign(value);
  }
  inline void UserDictionary_Entry::set_value(const char* value) {
    set_has_value();
    if (value_ == &::google::protobuf::internal::kEmptyString) {
      value_ = new ::std::string;
    }
    value_->assign(value);
  }
  inline void UserDictionary_Entry::set_value(const char* value, size_t size) {
    set_has_value();
    if (value_ == &::google::protobuf::internal::kEmptyString) {
      value_ = new ::std::string;
    }
    value_->assign(reinterpret_cast<const char*>(value), size);
  }
  inline ::std::string* UserDictionary_Entry::mutable_value() {
    set_has_value();
    if (value_ == &::google::protobuf::internal::kEmptyString) {
      value_ = new ::std::string;
    }
    return value_;
  }
  inline ::std::string* UserDictionary_Entry::release_value() {
    clear_has_value();
    if (value_ == &::google::protobuf::internal::kEmptyString) {
      return NULL;
    } else {
      ::std::string* temp = value_;
      value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
      return temp;
    }
  }
  inline void UserDictionary_Entry::set_allocated_value(::std::string* value) {
    if (value_ != &::google::protobuf::internal::kEmptyString) {
      delete value_;
    }
    if (value) {
      set_has_value();
      value_ = value;
    } else {
      clear_has_value();
      value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    }
  }
  
  // optional string comment = 4 [default = ""];
  inline bool UserDictionary_Entry::has_comment() const {
    return (_has_bits_[0] & 0x00000004u) != 0;
  }
  inline void UserDictionary_Entry::set_has_comment() {
    _has_bits_[0] |= 0x00000004u;
  }
  inline void UserDictionary_Entry::clear_has_comment() {
    _has_bits_[0] &= ~0x00000004u;
  }
  inline void UserDictionary_Entry::clear_comment() {
    if (comment_ != &::google::protobuf::internal::kEmptyString) {
      comment_->clear();
    }
    clear_has_comment();
  }
  inline const ::std::string& UserDictionary_Entry::comment() const {
    return *comment_;
  }
  inline void UserDictionary_Entry::set_comment(const ::std::string& value) {
    set_has_comment();
    if (comment_ == &::google::protobuf::internal::kEmptyString) {
      comment_ = new ::std::string;
    }
    comment_->assign(value);
  }
  inline void UserDictionary_Entry::set_comment(const char* value) {
    set_has_comment();
    if (comment_ == &::google::protobuf::internal::kEmptyString) {
      comment_ = new ::std::string;
    }
    comment_->assign(value);
  }
  inline void UserDictionary_Entry::set_comment(const char* value, size_t size) {
    set_has_comment();
    if (comment_ == &::google::protobuf::internal::kEmptyString) {
      comment_ = new ::std::string;
    }
    comment_->assign(reinterpret_cast<const char*>(value), size);
  }
  inline ::std::string* UserDictionary_Entry::mutable_comment() {
    set_has_comment();
    if (comment_ == &::google::protobuf::internal::kEmptyString) {
      comment_ = new ::std::string;
    }
    return comment_;
  }
  inline ::std::string* UserDictionary_Entry::release_comment() {
    clear_has_comment();
    if (comment_ == &::google::protobuf::internal::kEmptyString) {
      return NULL;
    } else {
      ::std::string* temp = comment_;
      comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
      return temp;
    }
  }
  inline void UserDictionary_Entry::set_allocated_comment(::std::string* comment) {
    if (comment_ != &::google::protobuf::internal::kEmptyString) {
      delete comment_;
    }
    if (comment) {
      set_has_comment();
      comment_ = comment;
    } else {
      clear_has_comment();
      comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    }
  }
  
  // optional .mozc.user_dictionary.UserDictionary.PosType pos = 5;
  inline bool UserDictionary_Entry::has_pos() const {
    return (_has_bits_[0] & 0x00000008u) != 0;
  }
  inline void UserDictionary_Entry::set_has_pos() {
    _has_bits_[0] |= 0x00000008u;
  }
  inline void UserDictionary_Entry::clear_has_pos() {
    _has_bits_[0] &= ~0x00000008u;
  }
  inline void UserDictionary_Entry::clear_pos() {
    pos_ = 1;
    clear_has_pos();
  }
  inline ::mozc::user_dictionary::UserDictionary_PosType UserDictionary_Entry::pos() const {
    return static_cast< ::mozc::user_dictionary::UserDictionary_PosType >(pos_);
  }
  inline void UserDictionary_Entry::set_pos(::mozc::user_dictionary::UserDictionary_PosType value) {
    assert(::mozc::user_dictionary::UserDictionary_PosType_IsValid(value));
    set_has_pos();
    pos_ = value;
  }
  
  // optional bool removed = 10 [default = false];
  inline bool UserDictionary_Entry::has_removed() const {
    return (_has_bits_[0] & 0x00000010u) != 0;
  }
  inline void UserDictionary_Entry::set_has_removed() {
    _has_bits_[0] |= 0x00000010u;
  }
  inline void UserDictionary_Entry::clear_has_removed() {
    _has_bits_[0] &= ~0x00000010u;
  }
  inline void UserDictionary_Entry::clear_removed() {
    removed_ = false;
    clear_has_removed();
  }
  inline bool UserDictionary_Entry::removed() const {
    return removed_;
  }
  inline void UserDictionary_Entry::set_removed(bool value) {
    set_has_removed();
    removed_ = value;
  }
  
  // optional bool auto_registered = 11 [default = false];
  inline bool UserDictionary_Entry::has_auto_registered() const {
    return (_has_bits_[0] & 0x00000020u) != 0;
  }
  inline void UserDictionary_Entry::set_has_auto_registered() {
    _has_bits_[0] |= 0x00000020u;
  }
  inline void UserDictionary_Entry::clear_has_auto_registered() {
    _has_bits_[0] &= ~0x00000020u;
  }
  inline void UserDictionary_Entry::clear_auto_registered() {
    auto_registered_ = false;
    clear_has_auto_registered();
  }
  inline bool UserDictionary_Entry::auto_registered() const {
    return auto_registered_;
  }
  inline void UserDictionary_Entry::set_auto_registered(bool value) {
    set_has_auto_registered();
    auto_registered_ = value;
  }
  
  // -------------------------------------------------------------------
  
  // UserDictionary
  
  // optional uint64 id = 1 [default = 0];
  inline bool UserDictionary::has_id() const {
    return (_has_bits_[0] & 0x00000001u) != 0;
  }
  inline void UserDictionary::set_has_id() {
    _has_bits_[0] |= 0x00000001u;
  }
  inline void UserDictionary::clear_has_id() {
    _has_bits_[0] &= ~0x00000001u;
  }
  inline void UserDictionary::clear_id() {
    id_ = GOOGLE_ULONGLONG(0);
    clear_has_id();
  }
  inline ::google::protobuf::uint64 UserDictionary::id() const {
    return id_;
  }
  inline void UserDictionary::set_id(::google::protobuf::uint64 value) {
    set_has_id();
    id_ = value;
  }
  
  // optional bool enabled = 2 [default = true];
  inline bool UserDictionary::has_enabled() const {
    return (_has_bits_[0] & 0x00000002u) != 0;
  }
  inline void UserDictionary::set_has_enabled() {
    _has_bits_[0] |= 0x00000002u;
  }
  inline void UserDictionary::clear_has_enabled() {
    _has_bits_[0] &= ~0x00000002u;
  }
  inline void UserDictionary::clear_enabled() {
    enabled_ = true;
    clear_has_enabled();
  }
  inline bool UserDictionary::enabled() const {
    return enabled_;
  }
  inline void UserDictionary::set_enabled(bool value) {
    set_has_enabled();
    enabled_ = value;
  }
  
  // optional string name = 3 [default = ""];
  inline bool UserDictionary::has_name() const {
    return (_has_bits_[0] & 0x00000004u) != 0;
  }
  inline void UserDictionary::set_has_name() {
    _has_bits_[0] |= 0x00000004u;
  }
  inline void UserDictionary::clear_has_name() {
    _has_bits_[0] &= ~0x00000004u;
  }
  inline void UserDictionary::clear_name() {
    if (name_ != &::google::protobuf::internal::kEmptyString) {
      name_->clear();
    }
    clear_has_name();
  }
  inline const ::std::string& UserDictionary::name() const {
    return *name_;
  }
  inline void UserDictionary::set_name(const ::std::string& value) {
    set_has_name();
    if (name_ == &::google::protobuf::internal::kEmptyString) {
      name_ = new ::std::string;
    }
    name_->assign(value);
  }
  inline void UserDictionary::set_name(const char* value) {
    set_has_name();
    if (name_ == &::google::protobuf::internal::kEmptyString) {
      name_ = new ::std::string;
    }
    name_->assign(value);
  }
  inline void UserDictionary::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* UserDictionary::mutable_name() {
    set_has_name();
    if (name_ == &::google::protobuf::internal::kEmptyString) {
      name_ = new ::std::string;
    }
    return name_;
  }
  inline ::std::string* UserDictionary::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;
    }
  }
  inline void UserDictionary::set_allocated_name(::std::string* name) {
    if (name_ != &::google::protobuf::internal::kEmptyString) {
      delete name_;
    }
    if (name) {
      set_has_name();
      name_ = name;
    } else {
      clear_has_name();
      name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    }
  }
  
  // repeated .mozc.user_dictionary.UserDictionary.Entry entries = 4;
  inline int UserDictionary::entries_size() const {
    return entries_.size();
  }
  inline void UserDictionary::clear_entries() {
    entries_.Clear();
  }
  inline const ::mozc::user_dictionary::UserDictionary_Entry& UserDictionary::entries(int index) const {
    return entries_.Get(index);
  }
  inline ::mozc::user_dictionary::UserDictionary_Entry* UserDictionary::mutable_entries(int index) {
    return entries_.Mutable(index);
  }
  inline ::mozc::user_dictionary::UserDictionary_Entry* UserDictionary::add_entries() {
    return entries_.Add();
  }
  inline const ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry >&
  UserDictionary::entries() const {
    return entries_;
  }
  inline ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry >*
  UserDictionary::mutable_entries() {
    return &entries_;
  }
  
  // optional bool removed = 5 [default = false];
  inline bool UserDictionary::has_removed() const {
    return (_has_bits_[0] & 0x00000010u) != 0;
  }
  inline void UserDictionary::set_has_removed() {
    _has_bits_[0] |= 0x00000010u;
  }
  inline void UserDictionary::clear_has_removed() {
    _has_bits_[0] &= ~0x00000010u;
  }
  inline void UserDictionary::clear_removed() {
    removed_ = false;
    clear_has_removed();
  }
  inline bool UserDictionary::removed() const {
    return removed_;
  }
  inline void UserDictionary::set_removed(bool value) {
    set_has_removed();
    removed_ = value;
  }
  
  // optional bool syncable = 6 [default = false];
  inline bool UserDictionary::has_syncable() const {
    return (_has_bits_[0] & 0x00000020u) != 0;
  }
  inline void UserDictionary::set_has_syncable() {
    _has_bits_[0] |= 0x00000020u;
  }
  inline void UserDictionary::clear_has_syncable() {
    _has_bits_[0] &= ~0x00000020u;
  }
  inline void UserDictionary::clear_syncable() {
    syncable_ = false;
    clear_has_syncable();
  }
  inline bool UserDictionary::syncable() const {
    return syncable_;
  }
  inline void UserDictionary::set_syncable(bool value) {
    set_has_syncable();
    syncable_ = value;
  }
  
  // -------------------------------------------------------------------
  
  // UserDictionaryStorage
  
  // optional int32 version = 1 [default = 0];
  inline bool UserDictionaryStorage::has_version() const {
    return (_has_bits_[0] & 0x00000001u) != 0;
  }
  inline void UserDictionaryStorage::set_has_version() {
    _has_bits_[0] |= 0x00000001u;
  }
  inline void UserDictionaryStorage::clear_has_version() {
    _has_bits_[0] &= ~0x00000001u;
  }
  inline void UserDictionaryStorage::clear_version() {
    version_ = 0;
    clear_has_version();
  }
  inline ::google::protobuf::int32 UserDictionaryStorage::version() const {
    return version_;
  }
  inline void UserDictionaryStorage::set_version(::google::protobuf::int32 value) {
    set_has_version();
    version_ = value;
  }
  
  // repeated .mozc.user_dictionary.UserDictionary dictionaries = 2;
  inline int UserDictionaryStorage::dictionaries_size() const {
    return dictionaries_.size();
  }
  inline void UserDictionaryStorage::clear_dictionaries() {
    dictionaries_.Clear();
  }
  inline const ::mozc::user_dictionary::UserDictionary& UserDictionaryStorage::dictionaries(int index) const {
    return dictionaries_.Get(index);
  }
  inline ::mozc::user_dictionary::UserDictionary* UserDictionaryStorage::mutable_dictionaries(int index) {
    return dictionaries_.Mutable(index);
  }
  inline ::mozc::user_dictionary::UserDictionary* UserDictionaryStorage::add_dictionaries() {
    return dictionaries_.Add();
  }
  inline const ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary >&
  UserDictionaryStorage::dictionaries() const {
    return dictionaries_;
  }
  inline ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary >*
  UserDictionaryStorage::mutable_dictionaries() {
    return &dictionaries_;
  }
  
  // optional .mozc.user_dictionary.UserDictionaryStorage.StorageType storage_type = 10 [default = SNAPSHOT];
  inline bool UserDictionaryStorage::has_storage_type() const {
    return (_has_bits_[0] & 0x00000004u) != 0;
  }
  inline void UserDictionaryStorage::set_has_storage_type() {
    _has_bits_[0] |= 0x00000004u;
  }
  inline void UserDictionaryStorage::clear_has_storage_type() {
    _has_bits_[0] &= ~0x00000004u;
  }
  inline void UserDictionaryStorage::clear_storage_type() {
    storage_type_ = 1;
    clear_has_storage_type();
  }
  inline ::mozc::user_dictionary::UserDictionaryStorage_StorageType UserDictionaryStorage::storage_type() const {
    return static_cast< ::mozc::user_dictionary::UserDictionaryStorage_StorageType >(storage_type_);
  }
  inline void UserDictionaryStorage::set_storage_type(::mozc::user_dictionary::UserDictionaryStorage_StorageType value) {
    assert(::mozc::user_dictionary::UserDictionaryStorage_StorageType_IsValid(value));
    set_has_storage_type();
    storage_type_ = value;
  }
  
  // -------------------------------------------------------------------
  
  // UserDictionaryCommand
  
  // required .mozc.user_dictionary.UserDictionaryCommand.CommandType type = 1;
  inline bool UserDictionaryCommand::has_type() const {
    return (_has_bits_[0] & 0x00000001u) != 0;
  }
  inline void UserDictionaryCommand::set_has_type() {
    _has_bits_[0] |= 0x00000001u;
  }
  inline void UserDictionaryCommand::clear_has_type() {
    _has_bits_[0] &= ~0x00000001u;
  }
  inline void UserDictionaryCommand::clear_type() {
    type_ = 0;
    clear_has_type();
  }
  inline ::mozc::user_dictionary::UserDictionaryCommand_CommandType UserDictionaryCommand::type() const {
    return static_cast< ::mozc::user_dictionary::UserDictionaryCommand_CommandType >(type_);
  }
  inline void UserDictionaryCommand::set_type(::mozc::user_dictionary::UserDictionaryCommand_CommandType value) {
    assert(::mozc::user_dictionary::UserDictionaryCommand_CommandType_IsValid(value));
    set_has_type();
    type_ = value;
  }
  
  // optional uint64 session_id = 2;
  inline bool UserDictionaryCommand::has_session_id() const {
    return (_has_bits_[0] & 0x00000002u) != 0;
  }
  inline void UserDictionaryCommand::set_has_session_id() {
    _has_bits_[0] |= 0x00000002u;
  }
  inline void UserDictionaryCommand::clear_has_session_id() {
    _has_bits_[0] &= ~0x00000002u;
  }
  inline void UserDictionaryCommand::clear_session_id() {
    session_id_ = GOOGLE_ULONGLONG(0);
    clear_has_session_id();
  }
  inline ::google::protobuf::uint64 UserDictionaryCommand::session_id() const {
    return session_id_;
  }
  inline void UserDictionaryCommand::set_session_id(::google::protobuf::uint64 value) {
    set_has_session_id();
    session_id_ = value;
  }
  
  // optional uint64 dictionary_id = 3;
  inline bool UserDictionaryCommand::has_dictionary_id() const {
    return (_has_bits_[0] & 0x00000004u) != 0;
  }
  inline void UserDictionaryCommand::set_has_dictionary_id() {
    _has_bits_[0] |= 0x00000004u;
  }
  inline void UserDictionaryCommand::clear_has_dictionary_id() {
    _has_bits_[0] &= ~0x00000004u;
  }
  inline void UserDictionaryCommand::clear_dictionary_id() {
    dictionary_id_ = GOOGLE_ULONGLONG(0);
    clear_has_dictionary_id();
  }
  inline ::google::protobuf::uint64 UserDictionaryCommand::dictionary_id() const {
    return dictionary_id_;
  }
  inline void UserDictionaryCommand::set_dictionary_id(::google::protobuf::uint64 value) {
    set_has_dictionary_id();
    dictionary_id_ = value;
  }
  
  // optional string dictionary_name = 4;
  inline bool UserDictionaryCommand::has_dictionary_name() const {
    return (_has_bits_[0] & 0x00000008u) != 0;
  }
  inline void UserDictionaryCommand::set_has_dictionary_name() {
    _has_bits_[0] |= 0x00000008u;
  }
  inline void UserDictionaryCommand::clear_has_dictionary_name() {
    _has_bits_[0] &= ~0x00000008u;
  }
  inline void UserDictionaryCommand::clear_dictionary_name() {
    if (dictionary_name_ != &::google::protobuf::internal::kEmptyString) {
      dictionary_name_->clear();
    }
    clear_has_dictionary_name();
  }
  inline const ::std::string& UserDictionaryCommand::dictionary_name() const {
    return *dictionary_name_;
  }
  inline void UserDictionaryCommand::set_dictionary_name(const ::std::string& value) {
    set_has_dictionary_name();
    if (dictionary_name_ == &::google::protobuf::internal::kEmptyString) {
      dictionary_name_ = new ::std::string;
    }
    dictionary_name_->assign(value);
  }
  inline void UserDictionaryCommand::set_dictionary_name(const char* value) {
    set_has_dictionary_name();
    if (dictionary_name_ == &::google::protobuf::internal::kEmptyString) {
      dictionary_name_ = new ::std::string;
    }
    dictionary_name_->assign(value);
  }
  inline void UserDictionaryCommand::set_dictionary_name(const char* value, size_t size) {
    set_has_dictionary_name();
    if (dictionary_name_ == &::google::protobuf::internal::kEmptyString) {
      dictionary_name_ = new ::std::string;
    }
    dictionary_name_->assign(reinterpret_cast<const char*>(value), size);
  }
  inline ::std::string* UserDictionaryCommand::mutable_dictionary_name() {
    set_has_dictionary_name();
    if (dictionary_name_ == &::google::protobuf::internal::kEmptyString) {
      dictionary_name_ = new ::std::string;
    }
    return dictionary_name_;
  }
  inline ::std::string* UserDictionaryCommand::release_dictionary_name() {
    clear_has_dictionary_name();
    if (dictionary_name_ == &::google::protobuf::internal::kEmptyString) {
      return NULL;
    } else {
      ::std::string* temp = dictionary_name_;
      dictionary_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
      return temp;
    }
  }
  inline void UserDictionaryCommand::set_allocated_dictionary_name(::std::string* dictionary_name) {
    if (dictionary_name_ != &::google::protobuf::internal::kEmptyString) {
      delete dictionary_name_;
    }
    if (dictionary_name) {
      set_has_dictionary_name();
      dictionary_name_ = dictionary_name;
    } else {
      clear_has_dictionary_name();
      dictionary_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    }
  }
  
  // repeated int32 entry_index = 5;
  inline int UserDictionaryCommand::entry_index_size() const {
    return entry_index_.size();
  }
  inline void UserDictionaryCommand::clear_entry_index() {
    entry_index_.Clear();
  }
  inline ::google::protobuf::int32 UserDictionaryCommand::entry_index(int index) const {
    return entry_index_.Get(index);
  }
  inline void UserDictionaryCommand::set_entry_index(int index, ::google::protobuf::int32 value) {
    entry_index_.Set(index, value);
  }
  inline void UserDictionaryCommand::add_entry_index(::google::protobuf::int32 value) {
    entry_index_.Add(value);
  }
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
  UserDictionaryCommand::entry_index() const {
    return entry_index_;
  }
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
  UserDictionaryCommand::mutable_entry_index() {
    return &entry_index_;
  }
  
  // optional .mozc.user_dictionary.UserDictionary.Entry entry = 6;
  inline bool UserDictionaryCommand::has_entry() const {
    return (_has_bits_[0] & 0x00000020u) != 0;
  }
  inline void UserDictionaryCommand::set_has_entry() {
    _has_bits_[0] |= 0x00000020u;
  }
  inline void UserDictionaryCommand::clear_has_entry() {
    _has_bits_[0] &= ~0x00000020u;
  }
  inline void UserDictionaryCommand::clear_entry() {
    if (entry_ != NULL) entry_->::mozc::user_dictionary::UserDictionary_Entry::Clear();
    clear_has_entry();
  }
  inline const ::mozc::user_dictionary::UserDictionary_Entry& UserDictionaryCommand::entry() const {
    return entry_ != NULL ? *entry_ : *default_instance_->entry_;
  }
  inline ::mozc::user_dictionary::UserDictionary_Entry* UserDictionaryCommand::mutable_entry() {
    set_has_entry();
    if (entry_ == NULL) entry_ = new ::mozc::user_dictionary::UserDictionary_Entry;
    return entry_;
  }
  inline ::mozc::user_dictionary::UserDictionary_Entry* UserDictionaryCommand::release_entry() {
    clear_has_entry();
    ::mozc::user_dictionary::UserDictionary_Entry* temp = entry_;
    entry_ = NULL;
    return temp;
  }
  inline void UserDictionaryCommand::set_allocated_entry(::mozc::user_dictionary::UserDictionary_Entry* entry) {
    delete entry_;
    entry_ = entry;
    if (entry) {
      set_has_entry();
    } else {
      clear_has_entry();
    }
  }
  
  // optional string data = 7;
  inline bool UserDictionaryCommand::has_data() const {
    return (_has_bits_[0] & 0x00000040u) != 0;
  }
  inline void UserDictionaryCommand::set_has_data() {
    _has_bits_[0] |= 0x00000040u;
  }
  inline void UserDictionaryCommand::clear_has_data() {
    _has_bits_[0] &= ~0x00000040u;
  }
  inline void UserDictionaryCommand::clear_data() {
    if (data_ != &::google::protobuf::internal::kEmptyString) {
      data_->clear();
    }
    clear_has_data();
  }
  inline const ::std::string& UserDictionaryCommand::data() const {
    return *data_;
  }
  inline void UserDictionaryCommand::set_data(const ::std::string& value) {
    set_has_data();
    if (data_ == &::google::protobuf::internal::kEmptyString) {
      data_ = new ::std::string;
    }
    data_->assign(value);
  }
  inline void UserDictionaryCommand::set_data(const char* value) {
    set_has_data();
    if (data_ == &::google::protobuf::internal::kEmptyString) {
      data_ = new ::std::string;
    }
    data_->assign(value);
  }
  inline void UserDictionaryCommand::set_data(const char* value, size_t size) {
    set_has_data();
    if (data_ == &::google::protobuf::internal::kEmptyString) {
      data_ = new ::std::string;
    }
    data_->assign(reinterpret_cast<const char*>(value), size);
  }
  inline ::std::string* UserDictionaryCommand::mutable_data() {
    set_has_data();
    if (data_ == &::google::protobuf::internal::kEmptyString) {
      data_ = new ::std::string;
    }
    return data_;
  }
  inline ::std::string* UserDictionaryCommand::release_data() {
    clear_has_data();
    if (data_ == &::google::protobuf::internal::kEmptyString) {
      return NULL;
    } else {
      ::std::string* temp = data_;
      data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
      return temp;
    }
  }
  inline void UserDictionaryCommand::set_allocated_data(::std::string* data) {
    if (data_ != &::google::protobuf::internal::kEmptyString) {
      delete data_;
    }
    if (data) {
      set_has_data();
      data_ = data;
    } else {
      clear_has_data();
      data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    }
  }
  
  // optional bool ensure_non_empty_storage = 8;
  inline bool UserDictionaryCommand::has_ensure_non_empty_storage() const {
    return (_has_bits_[0] & 0x00000080u) != 0;
  }
  inline void UserDictionaryCommand::set_has_ensure_non_empty_storage() {
    _has_bits_[0] |= 0x00000080u;
  }
  inline void UserDictionaryCommand::clear_has_ensure_non_empty_storage() {
    _has_bits_[0] &= ~0x00000080u;
  }
  inline void UserDictionaryCommand::clear_ensure_non_empty_storage() {
    ensure_non_empty_storage_ = false;
    clear_has_ensure_non_empty_storage();
  }
  inline bool UserDictionaryCommand::ensure_non_empty_storage() const {
    return ensure_non_empty_storage_;
  }
  inline void UserDictionaryCommand::set_ensure_non_empty_storage(bool value) {
    set_has_ensure_non_empty_storage();
    ensure_non_empty_storage_ = value;
  }
  
  // -------------------------------------------------------------------
  
  // UserDictionaryCommandStatus
  
  // required .mozc.user_dictionary.UserDictionaryCommandStatus.Status status = 1;
  inline bool UserDictionaryCommandStatus::has_status() const {
    return (_has_bits_[0] & 0x00000001u) != 0;
  }
  inline void UserDictionaryCommandStatus::set_has_status() {
    _has_bits_[0] |= 0x00000001u;
  }
  inline void UserDictionaryCommandStatus::clear_has_status() {
    _has_bits_[0] &= ~0x00000001u;
  }
  inline void UserDictionaryCommandStatus::clear_status() {
    status_ = 1;
    clear_has_status();
  }
  inline ::mozc::user_dictionary::UserDictionaryCommandStatus_Status UserDictionaryCommandStatus::status() const {
    return static_cast< ::mozc::user_dictionary::UserDictionaryCommandStatus_Status >(status_);
  }
  inline void UserDictionaryCommandStatus::set_status(::mozc::user_dictionary::UserDictionaryCommandStatus_Status value) {
    assert(::mozc::user_dictionary::UserDictionaryCommandStatus_Status_IsValid(value));
    set_has_status();
    status_ = value;
  }
  
  // optional uint64 session_id = 2;
  inline bool UserDictionaryCommandStatus::has_session_id() const {
    return (_has_bits_[0] & 0x00000002u) != 0;
  }
  inline void UserDictionaryCommandStatus::set_has_session_id() {
    _has_bits_[0] |= 0x00000002u;
  }
  inline void UserDictionaryCommandStatus::clear_has_session_id() {
    _has_bits_[0] &= ~0x00000002u;
  }
  inline void UserDictionaryCommandStatus::clear_session_id() {
    session_id_ = GOOGLE_ULONGLONG(0);
    clear_has_session_id();
  }
  inline ::google::protobuf::uint64 UserDictionaryCommandStatus::session_id() const {
    return session_id_;
  }
  inline void UserDictionaryCommandStatus::set_session_id(::google::protobuf::uint64 value) {
    set_has_session_id();
    session_id_ = value;
  }
  
  // optional .mozc.user_dictionary.UserDictionaryStorage storage = 3;
  inline bool UserDictionaryCommandStatus::has_storage() const {
    return (_has_bits_[0] & 0x00000004u) != 0;
  }
  inline void UserDictionaryCommandStatus::set_has_storage() {
    _has_bits_[0] |= 0x00000004u;
  }
  inline void UserDictionaryCommandStatus::clear_has_storage() {
    _has_bits_[0] &= ~0x00000004u;
  }
  inline void UserDictionaryCommandStatus::clear_storage() {
    if (storage_ != NULL) storage_->::mozc::user_dictionary::UserDictionaryStorage::Clear();
    clear_has_storage();
  }
  inline const ::mozc::user_dictionary::UserDictionaryStorage& UserDictionaryCommandStatus::storage() const {
    return storage_ != NULL ? *storage_ : *default_instance_->storage_;
  }
  inline ::mozc::user_dictionary::UserDictionaryStorage* UserDictionaryCommandStatus::mutable_storage() {
    set_has_storage();
    if (storage_ == NULL) storage_ = new ::mozc::user_dictionary::UserDictionaryStorage;
    return storage_;
  }
  inline ::mozc::user_dictionary::UserDictionaryStorage* UserDictionaryCommandStatus::release_storage() {
    clear_has_storage();
    ::mozc::user_dictionary::UserDictionaryStorage* temp = storage_;
    storage_ = NULL;
    return temp;
  }
  inline void UserDictionaryCommandStatus::set_allocated_storage(::mozc::user_dictionary::UserDictionaryStorage* storage) {
    delete storage_;
    storage_ = storage;
    if (storage) {
      set_has_storage();
    } else {
      clear_has_storage();
    }
  }
  
  // optional .mozc.user_dictionary.UserDictionary.Entry OBSOLETE_entry = 4;
  inline bool UserDictionaryCommandStatus::has_obsolete_entry() const {
    return (_has_bits_[0] & 0x00000008u) != 0;
  }
  inline void UserDictionaryCommandStatus::set_has_obsolete_entry() {
    _has_bits_[0] |= 0x00000008u;
  }
  inline void UserDictionaryCommandStatus::clear_has_obsolete_entry() {
    _has_bits_[0] &= ~0x00000008u;
  }
  inline void UserDictionaryCommandStatus::clear_obsolete_entry() {
    if (obsolete_entry_ != NULL) obsolete_entry_->::mozc::user_dictionary::UserDictionary_Entry::Clear();
    clear_has_obsolete_entry();
  }
  inline const ::mozc::user_dictionary::UserDictionary_Entry& UserDictionaryCommandStatus::obsolete_entry() const {
    return obsolete_entry_ != NULL ? *obsolete_entry_ : *default_instance_->obsolete_entry_;
  }
  inline ::mozc::user_dictionary::UserDictionary_Entry* UserDictionaryCommandStatus::mutable_obsolete_entry() {
    set_has_obsolete_entry();
    if (obsolete_entry_ == NULL) obsolete_entry_ = new ::mozc::user_dictionary::UserDictionary_Entry;
    return obsolete_entry_;
  }
  inline ::mozc::user_dictionary::UserDictionary_Entry* UserDictionaryCommandStatus::release_obsolete_entry() {
    clear_has_obsolete_entry();
    ::mozc::user_dictionary::UserDictionary_Entry* temp = obsolete_entry_;
    obsolete_entry_ = NULL;
    return temp;
  }
  inline void UserDictionaryCommandStatus::set_allocated_obsolete_entry(::mozc::user_dictionary::UserDictionary_Entry* obsolete_entry) {
    delete obsolete_entry_;
    obsolete_entry_ = obsolete_entry;
    if (obsolete_entry) {
      set_has_obsolete_entry();
    } else {
      clear_has_obsolete_entry();
    }
  }
  
  // optional uint64 dictionary_id = 5;
  inline bool UserDictionaryCommandStatus::has_dictionary_id() const {
    return (_has_bits_[0] & 0x00000010u) != 0;
  }
  inline void UserDictionaryCommandStatus::set_has_dictionary_id() {
    _has_bits_[0] |= 0x00000010u;
  }
  inline void UserDictionaryCommandStatus::clear_has_dictionary_id() {
    _has_bits_[0] &= ~0x00000010u;
  }
  inline void UserDictionaryCommandStatus::clear_dictionary_id() {
    dictionary_id_ = GOOGLE_ULONGLONG(0);
    clear_has_dictionary_id();
  }
  inline ::google::protobuf::uint64 UserDictionaryCommandStatus::dictionary_id() const {
    return dictionary_id_;
  }
  inline void UserDictionaryCommandStatus::set_dictionary_id(::google::protobuf::uint64 value) {
    set_has_dictionary_id();
    dictionary_id_ = value;
  }
  
  // optional uint32 entry_size = 6;
  inline bool UserDictionaryCommandStatus::has_entry_size() const {
    return (_has_bits_[0] & 0x00000020u) != 0;
  }
  inline void UserDictionaryCommandStatus::set_has_entry_size() {
    _has_bits_[0] |= 0x00000020u;
  }
  inline void UserDictionaryCommandStatus::clear_has_entry_size() {
    _has_bits_[0] &= ~0x00000020u;
  }
  inline void UserDictionaryCommandStatus::clear_entry_size() {
    entry_size_ = 0u;
    clear_has_entry_size();
  }
  inline ::google::protobuf::uint32 UserDictionaryCommandStatus::entry_size() const {
    return entry_size_;
  }
  inline void UserDictionaryCommandStatus::set_entry_size(::google::protobuf::uint32 value) {
    set_has_entry_size();
    entry_size_ = value;
  }
  
  // repeated .mozc.user_dictionary.UserDictionary.Entry entries = 7;
  inline int UserDictionaryCommandStatus::entries_size() const {
    return entries_.size();
  }
  inline void UserDictionaryCommandStatus::clear_entries() {
    entries_.Clear();
  }
  inline const ::mozc::user_dictionary::UserDictionary_Entry& UserDictionaryCommandStatus::entries(int index) const {
    return entries_.Get(index);
  }
  inline ::mozc::user_dictionary::UserDictionary_Entry* UserDictionaryCommandStatus::mutable_entries(int index) {
    return entries_.Mutable(index);
  }
  inline ::mozc::user_dictionary::UserDictionary_Entry* UserDictionaryCommandStatus::add_entries() {
    return entries_.Add();
  }
  inline const ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry >&
  UserDictionaryCommandStatus::entries() const {
    return entries_;
  }
  inline ::google::protobuf::RepeatedPtrField< ::mozc::user_dictionary::UserDictionary_Entry >*
  UserDictionaryCommandStatus::mutable_entries() {
    return &entries_;
  }
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace user_dictionary
  }  // namespace mozc
  
  #ifndef SWIG
  namespace google {
  namespace protobuf {
  
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::mozc::user_dictionary::UserDictionary_PosType>() {
    return ::mozc::user_dictionary::UserDictionary_PosType_descriptor();
  }
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::mozc::user_dictionary::UserDictionaryStorage_StorageType>() {
    return ::mozc::user_dictionary::UserDictionaryStorage_StorageType_descriptor();
  }
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::mozc::user_dictionary::UserDictionaryCommand_CommandType>() {
    return ::mozc::user_dictionary::UserDictionaryCommand_CommandType_descriptor();
  }
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::mozc::user_dictionary::UserDictionaryCommandStatus_Status>() {
    return ::mozc::user_dictionary::UserDictionaryCommandStatus_Status_descriptor();
  }
  
  }  // namespace google
  }  // namespace protobuf
  #endif  // SWIG
  
  // @@protoc_insertion_point(global_scope)
  
  #endif  // PROTOBUF_dictionary_2fuser_5fdictionary_5fstorage_2eproto__INCLUDED
  