diff --git a/td/telegram/files/FileDb.cpp b/td/telegram/files/FileDb.cpp
index 9290d48b..e12f3dd1 100644
--- a/td/telegram/files/FileDb.cpp
+++ b/td/telegram/files/FileDb.cpp
@@ -176,30 +176,30 @@ class FileDb : public FileDbInterface {
 
   void clear_file_data(Id id, const FileData &file_data) override {
     string remote_key;
-    if (file_data.remote_.type_ == RemoteFileLocation::Type::Full) {
+    if (file_data.remote_.type() == RemoteFileLocation::Type::Full) {
       remote_key = as_key(file_data.remote_.full());
     }
     string local_key;
-    if (file_data.local_.type_ == LocalFileLocation::Type::Full) {
+    if (file_data.local_.type() == LocalFileLocation::Type::Full) {
       local_key = as_key(file_data.local_.full());
     }
     string generate_key;
-    if (file_data.generate_.type_ == GenerateFileLocation::Type::Full) {
+    if (file_data.generate_.type() == GenerateFileLocation::Type::Full) {
       generate_key = as_key(file_data.generate_.full());
     }
     send_closure(file_db_actor_, &FileDbActor::clear_file_data, id, remote_key, local_key, generate_key);
   }
   void set_file_data(Id id, const FileData &file_data, bool new_remote, bool new_local, bool new_generate) override {
     string remote_key;
-    if (file_data.remote_.type_ == RemoteFileLocation::Type::Full && new_remote) {
+    if (file_data.remote_.type() == RemoteFileLocation::Type::Full && new_remote) {
       remote_key = as_key(file_data.remote_.full());
     }
     string local_key;
-    if (file_data.local_.type_ == LocalFileLocation::Type::Full && new_local) {
+    if (file_data.local_.type() == LocalFileLocation::Type::Full && new_local) {
       local_key = as_key(file_data.local_.full());
     }
     string generate_key;
-    if (file_data.generate_.type_ == GenerateFileLocation::Type::Full && new_generate) {
+    if (file_data.generate_.type() == GenerateFileLocation::Type::Full && new_generate) {
       generate_key = as_key(file_data.generate_.full());
     }
     LOG(DEBUG) << "SAVE " << id << " -> " << file_data << " "
diff --git a/td/telegram/files/FileDownloader.cpp b/td/telegram/files/FileDownloader.cpp
index b63ded71..4d3d5a0a 100644
--- a/td/telegram/files/FileDownloader.cpp
+++ b/td/telegram/files/FileDownloader.cpp
@@ -45,12 +45,12 @@ Result<FileLoader::FileInfo> FileDownloader::init() {
   SCOPE_EXIT {
     try_release_fd();
   };
-  if (local_.type_ == LocalFileLocation::Type::Full) {
+  if (local_.type() == LocalFileLocation::Type::Full) {
     return Status::Error("File is already downloaded");
   }
   int offset = 0;
   int32 part_size = 0;
-  if (local_.type_ == LocalFileLocation::Type::Partial) {
+  if (local_.type() == LocalFileLocation::Type::Partial) {
     const auto &partial = local_.partial();
     path_ = partial.path_;
     auto result_fd = FileFd::open(path_, FileFd::Write | FileFd::Read);
@@ -80,11 +80,11 @@ Result<FileLoader::FileInfo> FileDownloader::init() {
   return res;
 }
 Status FileDownloader::on_ok(int64 size) {
-  auto dir = get_files_dir(remote_.type_);
+  auto dir = get_files_dir(remote_.file_type_);
 
   TRY_RESULT(perm_path, create_from_temp(path_, dir, name_));
   fd_.close();
-  callback_->on_ok(FullLocalFileLocation(remote_.type_, std::move(perm_path), 0), size);
+  callback_->on_ok(FullLocalFileLocation(remote_.file_type_, std::move(perm_path), 0), size);
   return Status::OK();
 }
 void FileDownloader::on_error(Status status) {
@@ -212,7 +212,7 @@ Result<std::pair<NetQueryPtr, bool>> FileDownloader::start_part(Part part, int32
       cdn_part_reupload_token_.erase(it);
     }
   }
-  net_query->file_type_ = narrow_cast<int32>(remote_.type_);
+  net_query->file_type_ = narrow_cast<int32>(remote_.file_type_);
   return std::make_pair(std::move(net_query), false);
 }
 
@@ -306,7 +306,7 @@ void FileDownloader::on_progress(int32 part_count, int32 part_size, int32 ready_
     return;
   }
   if (encryption_key_.empty()) {
-    callback_->on_partial_download(PartialLocalFileLocation{remote_.type_, path_, part_size, ready_part_count, ""},
+    callback_->on_partial_download(PartialLocalFileLocation{remote_.file_type_, path_, part_size, ready_part_count, ""},
                                    ready_size);
   } else {
     UInt256 iv;
@@ -315,9 +315,9 @@ void FileDownloader::on_progress(int32 part_count, int32 part_size, int32 ready_
     } else {
       LOG(FATAL) << tag("ready_part_count", ready_part_count) << tag("next_part", next_part_);
     }
-    callback_->on_partial_download(
-        PartialLocalFileLocation{remote_.type_, path_, part_size, ready_part_count, Slice(iv.raw, sizeof(iv)).str()},
-        ready_size);
+    callback_->on_partial_download(PartialLocalFileLocation{remote_.file_type_, path_, part_size, ready_part_count,
+                                                            Slice(iv.raw, sizeof(iv)).str()},
+                                   ready_size);
   }
 }
 
@@ -417,7 +417,7 @@ void FileDownloader::try_release_fd() {
 Status FileDownloader::acquire_fd() {
   if (fd_.empty()) {
     if (path_.empty()) {
-      TRY_RESULT(file_path, open_temp_file(remote_.type_));
+      TRY_RESULT(file_path, open_temp_file(remote_.file_type_));
       std::tie(fd_, path_) = std::move(file_path);
     } else {
       TRY_RESULT(fd, FileFd::open(path_, FileFd::Write | FileFd::Read));
diff --git a/td/telegram/files/FileGenerateManager.cpp b/td/telegram/files/FileGenerateManager.cpp
index 5b7588ec..de5d284e 100644
--- a/td/telegram/files/FileGenerateManager.cpp
+++ b/td/telegram/files/FileGenerateManager.cpp
@@ -87,7 +87,7 @@ class FileDownloadGenerateActor : public FileGenerateActor {
       auto file_view = G()->td().get_actor_unsafe()->file_manager_->get_file_view(file_id);
       if (file_view.has_local_location()) {
         auto location = file_view.local_location();
-        location.type_ = file_type;
+        location.file_type_ = file_type;
         callback->on_ok(location);
       } else {
         LOG(ERROR) << "Expected to have local location";
@@ -132,19 +132,19 @@ class FileExternalGenerateActor : public FileGenerateActor {
   ActorShared<> parent_;
 
   void start_up() override {
-    if (local_.type_ == LocalFileLocation::Type::Full) {
+    if (local_.type() == LocalFileLocation::Type::Full) {
       callback_->on_ok(local_.full());
       callback_.reset();
       return stop();
     }
 
-    if (local_.type_ == LocalFileLocation::Type::Partial) {
+    if (local_.type() == LocalFileLocation::Type::Partial) {
       const auto &partial = local_.partial();
       path_ = partial.path_;
       LOG(INFO) << "Unlink partially generated file at " << path_;
       unlink(path_).ignore();
     } else {
-      auto r_file_path = open_temp_file(generate_location_.type_);
+      auto r_file_path = open_temp_file(generate_location_.file_type_);
       if (r_file_path.is_error()) {
         return check_status(r_file_path.move_as_error());
       }
@@ -165,18 +165,18 @@ class FileExternalGenerateActor : public FileGenerateActor {
     if (local_prefix_size < 0) {
       return Status::Error(1, "Invalid local prefix size");
     }
-    callback_->on_partial_generate(PartialLocalFileLocation{generate_location_.type_, path_, 1, local_prefix_size, ""},
-                                   expected_size);
+    callback_->on_partial_generate(
+        PartialLocalFileLocation{generate_location_.file_type_, path_, 1, local_prefix_size, ""}, expected_size);
     return Status::OK();
   }
 
   Status do_file_generate_finish(Status status) {
     TRY_STATUS(std::move(status));
 
-    auto dir = get_files_dir(generate_location_.type_);
+    auto dir = get_files_dir(generate_location_.file_type_);
 
     TRY_RESULT(perm_path, create_from_temp(path_, dir, name_));
-    callback_->on_ok(FullLocalFileLocation(generate_location_.type_, std::move(perm_path), 0));
+    callback_->on_ok(FullLocalFileLocation(generate_location_.file_type_, std::move(perm_path), 0));
     callback_.reset();
     stop();
     return Status::OK();
@@ -224,7 +224,7 @@ void FileGenerateManager::generate_file(uint64 query_id, const FullGenerateFileL
   auto &query = it_flag.first->second;
   if (conversion.copy().truncate(file_id_query.size()) == file_id_query) {
     auto file_id = FileId(to_integer<int32>(conversion.substr(file_id_query.size())));
-    query.worker_ = create_actor<FileDownloadGenerateActor>("FileDownloadGenerateActor", generate_location.type_,
+    query.worker_ = create_actor<FileDownloadGenerateActor>("FileDownloadGenerateActor", generate_location.file_type_,
                                                             file_id, std::move(callback), std::move(parent));
   } else {
     query.worker_ = create_actor<FileExternalGenerateActor>("FileExternalGenerationActor", query_id, generate_location,
diff --git a/td/telegram/files/FileLocation.h b/td/telegram/files/FileLocation.h
index b6af573a..42b92fe4 100644
--- a/td/telegram/files/FileLocation.h
+++ b/td/telegram/files/FileLocation.h
@@ -394,7 +394,7 @@ inline StringBuilder &operator<<(StringBuilder &string_builder, const CommonRemo
 
 class FullRemoteFileLocation {
  public:
-  FileType type_{FileType::None};
+  FileType file_type_{FileType::None};
 
  private:
   static constexpr int32 WEB_LOCATION_FLAG = 1 << 24;
@@ -407,7 +407,7 @@ class FullRemoteFileLocation {
     if (is_web()) {
       return LocationType::Web;
     }
-    switch (type_) {
+    switch (file_type_) {
       case FileType::Photo:
       case FileType::ProfilePhoto:
       case FileType::Thumbnail:
@@ -455,7 +455,7 @@ class FullRemoteFileLocation {
                                    const FullRemoteFileLocation &full_remote_file_location);
 
   int32 full_type() const {
-    auto type = static_cast<int32>(type_);
+    auto type = static_cast<int32>(file_type_);
     if (is_web()) {
       type |= WEB_LOCATION_FLAG;
     }
@@ -483,7 +483,7 @@ class FullRemoteFileLocation {
     if (raw_type < 0 || raw_type >= static_cast<int32>(FileType::Size)) {
       return parser.set_error("Invalid FileType in FullRemoteFileLocation");
     }
-    type_ = static_cast<FileType>(raw_type);
+    file_type_ = static_cast<FileType>(raw_type);
     int32 dc_id_value;
     parse(dc_id_value, parser);
     dc_id_ = DcId::from_value(dc_id_value);
@@ -572,7 +572,7 @@ class FullRemoteFileLocation {
     return location_type() == LocationType::Common;
   }
   bool is_encrypted() const {
-    return type_ == FileType::Encrypted;
+    return file_type_ == FileType::Encrypted;
   }
 
   tl_object_ptr<telegram_api::inputWebFileLocation> as_input_web_file_location() const {
@@ -617,17 +617,17 @@ class FullRemoteFileLocation {
   FullRemoteFileLocation() = default;
   FullRemoteFileLocation(FileType file_type, int64 id, int64 access_hash, int32 local_id, int64 volume_id, int64 secret,
                          DcId dc_id)
-      : type_(file_type)
+      : file_type_(file_type)
       , dc_id_(dc_id)
       , variant_(PhotoRemoteFileLocation{id, access_hash, volume_id, secret, local_id}) {
     CHECK(is_photo());
   }
   FullRemoteFileLocation(FileType file_type, int64 id, int64 access_hash, DcId dc_id)
-      : type_(file_type), dc_id_(dc_id), variant_(CommonRemoteFileLocation{id, access_hash}) {
+      : file_type_(file_type), dc_id_(dc_id), variant_(CommonRemoteFileLocation{id, access_hash}) {
     CHECK(is_common());
   }
   FullRemoteFileLocation(FileType file_type, string url, int64 access_hash, DcId dc_id)
-      : type_(file_type)
+      : file_type_(file_type)
       , web_location_flag_{true}
       , dc_id_(dc_id)
       , variant_(WebRemoteFileLocation{std::move(url), access_hash}) {
@@ -681,7 +681,7 @@ class FullRemoteFileLocation {
 
 inline StringBuilder &operator<<(StringBuilder &string_builder,
                                  const FullRemoteFileLocation &full_remote_file_location) {
-  string_builder << "[" << file_type_name[static_cast<int32>(full_remote_file_location.type_)] << ", "
+  string_builder << "[" << file_type_name[static_cast<int32>(full_remote_file_location.file_type_)] << ", "
                  << full_remote_file_location.get_dc_id() << ", location = ";
 
   if (full_remote_file_location.is_web()) {
@@ -698,7 +698,10 @@ inline StringBuilder &operator<<(StringBuilder &string_builder,
 class RemoteFileLocation {
  public:
   enum class Type : int32 { Empty, Partial, Full };
-  Type type_;
+
+  Type type() const {
+    return type_;
+  }
 
   template <class StorerT>
   void store(StorerT &storer) const {
@@ -759,6 +762,7 @@ class RemoteFileLocation {
   }
 
  private:
+  Type type_;
   Variant<EmptyRemoteFileLocation, PartialRemoteFileLocation, FullRemoteFileLocation> variant_;
 
   friend bool operator==(const RemoteFileLocation &lhs, const RemoteFileLocation &rhs);
@@ -790,7 +794,7 @@ inline bool operator!=(const EmptyLocalFileLocation &lhs, const EmptyLocalFileLo
 }
 
 struct PartialLocalFileLocation {
-  FileType type_;
+  FileType file_type_;
   string path_;
   int32 part_size_;
   int32 ready_part_count_;
@@ -799,7 +803,7 @@ struct PartialLocalFileLocation {
   template <class StorerT>
   void store(StorerT &storer) const {
     using td::store;
-    store(type_, storer);
+    store(file_type_, storer);
     store(path_, storer);
     store(part_size_, storer);
     store(ready_part_count_, storer);
@@ -808,8 +812,8 @@ struct PartialLocalFileLocation {
   template <class ParserT>
   void parse(ParserT &parser) {
     using td::parse;
-    parse(type_, parser);
-    if (type_ < FileType::Thumbnail || type_ >= FileType::Size) {
+    parse(file_type_, parser);
+    if (file_type_ < FileType::Thumbnail || file_type_ >= FileType::Size) {
       return parser.set_error("Invalid type in PartialLocalFileLocation");
     }
     parse(path_, parser);
@@ -820,7 +824,7 @@ struct PartialLocalFileLocation {
 };
 
 inline bool operator==(const PartialLocalFileLocation &lhs, const PartialLocalFileLocation &rhs) {
-  return lhs.type_ == rhs.type_ && lhs.path_ == rhs.path_ && lhs.part_size_ == rhs.part_size_ &&
+  return lhs.file_type_ == rhs.file_type_ && lhs.path_ == rhs.path_ && lhs.part_size_ == rhs.part_size_ &&
          lhs.ready_part_count_ == rhs.ready_part_count_ && lhs.iv_ == rhs.iv_;
 }
 
@@ -829,22 +833,22 @@ inline bool operator!=(const PartialLocalFileLocation &lhs, const PartialLocalFi
 }
 
 struct FullLocalFileLocation {
-  FileType type_;
+  FileType file_type_;
   string path_;
   uint64 mtime_nsec_;
 
   template <class StorerT>
   void store(StorerT &storer) const {
     using td::store;
-    store(type_, storer);
+    store(file_type_, storer);
     store(mtime_nsec_, storer);
     store(path_, storer);
   }
   template <class ParserT>
   void parse(ParserT &parser) {
     using td::parse;
-    parse(type_, parser);
-    if (type_ < FileType::Thumbnail || type_ >= FileType::Size) {
+    parse(file_type_, parser);
+    if (file_type_ < FileType::Thumbnail || file_type_ >= FileType::Size) {
       return parser.set_error("Invalid type in FullLocalFileLocation");
     }
     parse(mtime_nsec_, parser);
@@ -855,21 +859,21 @@ struct FullLocalFileLocation {
   }
 
   // TODO: remove this constructor
-  FullLocalFileLocation() : type_(FileType::Photo) {
+  FullLocalFileLocation() : file_type_(FileType::Photo) {
   }
   FullLocalFileLocation(FileType file_type, string path, uint64 mtime_nsec)
-      : type_(file_type), path_(std::move(path)), mtime_nsec_(mtime_nsec) {
+      : file_type_(file_type), path_(std::move(path)), mtime_nsec_(mtime_nsec) {
   }
 
   static const int32 KEY_MAGIC = 0x84373817;
 };
 
 inline bool operator<(const FullLocalFileLocation &lhs, const FullLocalFileLocation &rhs) {
-  return std::tie(lhs.type_, lhs.mtime_nsec_, lhs.path_) < std::tie(rhs.type_, rhs.mtime_nsec_, rhs.path_);
+  return std::tie(lhs.file_type_, lhs.mtime_nsec_, lhs.path_) < std::tie(rhs.file_type_, rhs.mtime_nsec_, rhs.path_);
 }
 
 inline bool operator==(const FullLocalFileLocation &lhs, const FullLocalFileLocation &rhs) {
-  return std::tie(lhs.type_, lhs.mtime_nsec_, lhs.path_) == std::tie(rhs.type_, rhs.mtime_nsec_, rhs.path_);
+  return std::tie(lhs.file_type_, lhs.mtime_nsec_, lhs.path_) == std::tie(rhs.file_type_, rhs.mtime_nsec_, rhs.path_);
 }
 
 inline bool operator!=(const FullLocalFileLocation &lhs, const FullLocalFileLocation &rhs) {
@@ -883,7 +887,10 @@ inline StringBuilder &operator<<(StringBuilder &sb, const FullLocalFileLocation
 class LocalFileLocation {
  public:
   enum class Type : int32 { Empty, Partial, Full };
-  Type type_;
+
+  Type type() const {
+    return type_;
+  }
 
   PartialLocalFileLocation &partial() {
     return variant_.get<1>();
@@ -936,6 +943,7 @@ class LocalFileLocation {
   }
 
  private:
+  Type type_;
   Variant<EmptyLocalFileLocation, PartialLocalFileLocation, FullLocalFileLocation> variant_;
 
   friend bool operator==(const LocalFileLocation &lhs, const LocalFileLocation &rhs);
@@ -950,7 +958,7 @@ inline bool operator!=(const LocalFileLocation &lhs, const LocalFileLocation &rh
 }
 
 struct FullGenerateFileLocation {
-  FileType type_{FileType::None};
+  FileType file_type_{FileType::None};
   string original_path_;
   string conversion_;
   static const int32 KEY_MAGIC = 0x8b60a1c8;
@@ -958,14 +966,14 @@ struct FullGenerateFileLocation {
   template <class StorerT>
   void store(StorerT &storer) const {
     using td::store;
-    store(type_, storer);
+    store(file_type_, storer);
     store(original_path_, storer);
     store(conversion_, storer);
   }
   template <class ParserT>
   void parse(ParserT &parser) {
     using td::parse;
-    parse(type_, parser);
+    parse(file_type_, parser);
     parse(original_path_, parser);
     parse(conversion_, parser);
   }
@@ -974,19 +982,19 @@ struct FullGenerateFileLocation {
     return *this;
   }
   FullGenerateFileLocation() = default;
-  FullGenerateFileLocation(FileType type, string original_path, string conversion)
-      : type_(type), original_path_(std::move(original_path)), conversion_(std::move(conversion)) {
+  FullGenerateFileLocation(FileType file_type, string original_path, string conversion)
+      : file_type_(file_type), original_path_(std::move(original_path)), conversion_(std::move(conversion)) {
   }
 };
 
 inline bool operator<(const FullGenerateFileLocation &lhs, const FullGenerateFileLocation &rhs) {
-  return std::tie(lhs.type_, lhs.original_path_, lhs.conversion_) <
-         std::tie(rhs.type_, rhs.original_path_, rhs.conversion_);
+  return std::tie(lhs.file_type_, lhs.original_path_, lhs.conversion_) <
+         std::tie(rhs.file_type_, rhs.original_path_, rhs.conversion_);
 }
 
 inline bool operator==(const FullGenerateFileLocation &lhs, const FullGenerateFileLocation &rhs) {
-  return std::tie(lhs.type_, lhs.original_path_, lhs.conversion_) ==
-         std::tie(rhs.type_, rhs.original_path_, rhs.conversion_);
+  return std::tie(lhs.file_type_, lhs.original_path_, lhs.conversion_) ==
+         std::tie(rhs.file_type_, rhs.original_path_, rhs.conversion_);
 }
 
 inline bool operator!=(const FullGenerateFileLocation &lhs, const FullGenerateFileLocation &rhs) {
@@ -996,7 +1004,7 @@ inline bool operator!=(const FullGenerateFileLocation &lhs, const FullGenerateFi
 inline StringBuilder &operator<<(StringBuilder &string_builder,
                                  const FullGenerateFileLocation &full_generated_file_location) {
   return string_builder << "["
-                        << tag("file_type", file_type_name[static_cast<int32>(full_generated_file_location.type_)])
+                        << tag("file_type", file_type_name[static_cast<int32>(full_generated_file_location.file_type_)])
                         << tag("original_path", full_generated_file_location.original_path_)
                         << tag("conversion", full_generated_file_location.conversion_) << "]";
 }
@@ -1004,7 +1012,10 @@ inline StringBuilder &operator<<(StringBuilder &string_builder,
 class GenerateFileLocation {
  public:
   enum class Type : int32 { Empty, Full };
-  Type type_;
+
+  Type type() const {
+    return type_;
+  }
 
   FullGenerateFileLocation &full() {
     CHECK(type_ == Type::Full);
@@ -1049,14 +1060,15 @@ class GenerateFileLocation {
   }
 
  private:
+  Type type_;
   FullGenerateFileLocation full_;
 };
 
 inline bool operator==(const GenerateFileLocation &lhs, const GenerateFileLocation &rhs) {
-  if (lhs.type_ != rhs.type_) {
+  if (lhs.type() != rhs.type()) {
     return false;
   }
-  switch (lhs.type_) {
+  switch (lhs.type()) {
     case GenerateFileLocation::Type::Empty:
       return true;
     case GenerateFileLocation::Type::Full:
@@ -1138,10 +1150,10 @@ class FileData {
 };
 inline StringBuilder &operator<<(StringBuilder &sb, const FileData &file_data) {
   sb << "[" << tag("name", file_data.name_);
-  if (file_data.local_.type_ == LocalFileLocation::Type::Full) {
+  if (file_data.local_.type() == LocalFileLocation::Type::Full) {
     sb << " local " << file_data.local_.full();
   }
-  if (file_data.remote_.type_ == RemoteFileLocation::Type::Full) {
+  if (file_data.remote_.type() == RemoteFileLocation::Type::Full) {
     sb << " remote " << file_data.remote_.full();
   }
   return sb << "]";
diff --git a/td/telegram/files/FileManager.cpp b/td/telegram/files/FileManager.cpp
index 16633d72..043f9ac6 100644
--- a/td/telegram/files/FileManager.cpp
+++ b/td/telegram/files/FileManager.cpp
@@ -57,7 +57,7 @@ void FileNode::set_remote_location(const RemoteFileLocation &remote, FileLocatio
     on_info_changed();
   }
   if (remote_ == remote) {
-    if (remote_.type_ == RemoteFileLocation::Type::Full) {
+    if (remote_.type() == RemoteFileLocation::Type::Full) {
       if (remote_.full().get_access_hash() == remote.full().get_access_hash()) {
         return;
       }
@@ -178,22 +178,22 @@ bool FileNode::need_pmc_flush() const {
 
   // We must save encryption key
   if (!encryption_key_.empty()) {
-    // && remote_.type_ != RemoteFileLocation::Type::Empty
+    // && remote_.type() != RemoteFileLocation::Type::Empty
     return true;
   }
 
-  bool has_generate_location = generate_.type_ == GenerateFileLocation::Type::Full;
+  bool has_generate_location = generate_.type() == GenerateFileLocation::Type::Full;
   // Do not save "#file_id#" conversion.
   if (has_generate_location && begins_with(generate_.full().conversion_, "#file_id#")) {
     has_generate_location = false;
   }
 
-  if (remote_.type_ == RemoteFileLocation::Type::Full &&
-      (has_generate_location || local_.type_ != LocalFileLocation::Type::Empty)) {
+  if (remote_.type() == RemoteFileLocation::Type::Full &&
+      (has_generate_location || local_.type() != LocalFileLocation::Type::Empty)) {
     return true;
   }
-  if (local_.type_ == LocalFileLocation::Type::Full &&
-      (has_generate_location || remote_.type_ != RemoteFileLocation::Type::Empty)) {
+  if (local_.type() == LocalFileLocation::Type::Full &&
+      (has_generate_location || remote_.type() != RemoteFileLocation::Type::Empty)) {
     return true;
   }
 
@@ -211,21 +211,21 @@ void FileNode::on_info_flushed() {
 
 /*** FileView ***/
 bool FileView::has_local_location() const {
-  return node_->local_.type_ == LocalFileLocation::Type::Full;
+  return node_->local_.type() == LocalFileLocation::Type::Full;
 }
 const FullLocalFileLocation &FileView::local_location() const {
   CHECK(has_local_location());
   return node_->local_.full();
 }
 bool FileView::has_remote_location() const {
-  return node_->remote_.type_ == RemoteFileLocation::Type::Full;
+  return node_->remote_.type() == RemoteFileLocation::Type::Full;
 }
 const FullRemoteFileLocation &FileView::remote_location() const {
   CHECK(has_remote_location());
   return node_->remote_.full();
 }
 bool FileView::has_generate_location() const {
-  return node_->generate_.type_ == GenerateFileLocation::Type::Full;
+  return node_->generate_.type() == GenerateFileLocation::Type::Full;
 }
 const FullGenerateFileLocation &FileView::generate_location() const {
   CHECK(has_generate_location());
@@ -248,7 +248,7 @@ bool FileView::is_downloading() const {
 }
 
 int64 FileView::local_size() const {
-  switch (node_->local_.type_) {
+  switch (node_->local_.type()) {
     case LocalFileLocation::Type::Full:
       return node_->size_;
     case LocalFileLocation::Type::Partial:
@@ -258,7 +258,7 @@ int64 FileView::local_size() const {
   }
 }
 int64 FileView::local_total_size() const {
-  switch (node_->local_.type_) {
+  switch (node_->local_.type()) {
     case LocalFileLocation::Type::Empty:
       return 0;
     case LocalFileLocation::Type::Full:
@@ -278,7 +278,7 @@ bool FileView::is_uploading() const {
 }
 
 int64 FileView::remote_size() const {
-  switch (node_->remote_.type_) {
+  switch (node_->remote_.type()) {
     case RemoteFileLocation::Type::Full:
       return node_->size_;
     case RemoteFileLocation::Type::Partial: {
@@ -296,7 +296,7 @@ int64 FileView::remote_size() const {
 }
 
 string FileView::path() const {
-  switch (node_->local_.type_) {
+  switch (node_->local_.type()) {
     case LocalFileLocation::Type::Full:
       return node_->local_.full().path_;
     case LocalFileLocation::Type::Partial:
@@ -337,7 +337,7 @@ bool FileView::can_download_from_server() const {
   if (!has_remote_location()) {
     return false;
   }
-  if (remote_location().type_ == FileType::Encrypted && encryption_key().empty()) {
+  if (remote_location().file_type_ == FileType::Encrypted && encryption_key().empty()) {
     return false;
   }
   if (remote_location().get_dc_id().is_empty()) {
@@ -353,7 +353,7 @@ bool FileView::can_delete() const {
   if (has_local_location()) {
     return begins_with(local_location().path_, get_files_dir(get_type()));
   }
-  return node_->local_.type_ == LocalFileLocation::Type::Partial;
+  return node_->local_.type() == LocalFileLocation::Type::Partial;
 }
 
 /*** FileManager ***/
@@ -493,7 +493,7 @@ Status FileManager::check_local_location(FullLocalFileLocation &location, int64
     LOG(INFO) << "File was nodified: old mtime = " << location.mtime_nsec_ << ", new mtime = " << stat.mtime_nsec_;
     return Status::Error("File was modified");
   }
-  if ((location.type_ == FileType::Thumbnail || location.type_ == FileType::EncryptedThumbnail) &&
+  if ((location.file_type_ == FileType::Thumbnail || location.file_type_ == FileType::EncryptedThumbnail) &&
       size >= MAX_THUMBNAIL_SIZE) {
     return Status::Error(PSLICE() << "File is too big for thumbnail " << tag("size", format::as_size(size)));
   }
@@ -514,9 +514,9 @@ static Status check_partial_local_location(const PartialLocalFileLocation &locat
 
 Status FileManager::check_local_location(FileNode *node) {
   Status status;
-  if (node->local_.type_ == LocalFileLocation::Type::Full) {
+  if (node->local_.type() == LocalFileLocation::Type::Full) {
     status = check_local_location(node->local_.full(), node->size_);
-  } else if (node->local_.type_ == LocalFileLocation::Type::Partial) {
+  } else if (node->local_.type() == LocalFileLocation::Type::Partial) {
     status = check_partial_local_location(node->local_.partial());
   }
   if (status.is_error()) {
@@ -623,13 +623,13 @@ Result<FileId> FileManager::register_generate(FileType file_type, string origina
 
 Result<FileId> FileManager::register_file(FileData data, FileLocationSource file_location_source, const char *source,
                                           bool force) {
-  bool has_remote = data.remote_.type_ == RemoteFileLocation::Type::Full;
-  bool has_generate = data.generate_.type_ == GenerateFileLocation::Type::Full;
-  if (data.local_.type_ == LocalFileLocation::Type::Full && !force) {
+  bool has_remote = data.remote_.type() == RemoteFileLocation::Type::Full;
+  bool has_generate = data.generate_.type() == GenerateFileLocation::Type::Full;
+  if (data.local_.type() == LocalFileLocation::Type::Full && !force) {
     if (file_location_source == FileLocationSource::FromDb) {
       PathView path_view(data.local_.full().path_);
       if (path_view.is_relative()) {
-        data.local_.full().path_ = get_files_base_dir(data.local_.full().type_) + data.local_.full().path_;
+        data.local_.full().path_ = get_files_base_dir(data.local_.full().file_type_) + data.local_.full().path_;
       }
     }
 
@@ -643,7 +643,7 @@ Result<FileId> FileManager::register_file(FileData data, FileLocationSource file
       }
     }
   }
-  bool has_local = data.local_.type_ == LocalFileLocation::Type::Full;
+  bool has_local = data.local_.type() == LocalFileLocation::Type::Full;
   bool has_location = has_local || has_remote || has_generate;
   if (!has_location) {
     return Status::Error("No location");
@@ -711,8 +711,8 @@ Result<FileId> FileManager::register_file(FileData data, FileLocationSource file
 // 1 -- choose y
 // 2 -- choose any
 static int merge_choose(const LocalFileLocation &x, const LocalFileLocation &y) {
-  int32 x_type = static_cast<int32>(x.type_);
-  int32 y_type = static_cast<int32>(y.type_);
+  int32 x_type = static_cast<int32>(x.type());
+  int32 y_type = static_cast<int32>(y.type());
   if (x_type != y_type) {
     return x_type < y_type;
   }
@@ -720,13 +720,13 @@ static int merge_choose(const LocalFileLocation &x, const LocalFileLocation &y)
 }
 
 static int merge_choose(const RemoteFileLocation &x, int8 x_source, const RemoteFileLocation &y, int8 y_source) {
-  int32 x_type = static_cast<int32>(x.type_);
-  int32 y_type = static_cast<int32>(y.type_);
+  int32 x_type = static_cast<int32>(x.type());
+  int32 y_type = static_cast<int32>(y.type());
   if (x_type != y_type) {
     return x_type < y_type;
   }
   // If access_hash changed use a newer one
-  if (x.type_ == RemoteFileLocation::Type::Full) {
+  if (x.type() == RemoteFileLocation::Type::Full) {
     if (x.full().get_access_hash() != y.full().get_access_hash()) {
       return x_source < y_source;
     }
@@ -734,8 +734,8 @@ static int merge_choose(const RemoteFileLocation &x, int8 x_source, const Remote
   return 2;
 }
 static int merge_choose(const GenerateFileLocation &x, const GenerateFileLocation &y) {
-  int32 x_type = static_cast<int32>(x.type_);
-  int32 y_type = static_cast<int32>(y.type_);
+  int32 x_type = static_cast<int32>(x.type());
+  int32 y_type = static_cast<int32>(y.type());
   if (x_type != y_type) {
     return x_type < y_type;
   }
@@ -856,8 +856,8 @@ Result<FileId> FileManager::merge(FileId x_file_id, FileId y_file_id, bool no_sy
     y_node->upload_pause_ = FileId();
   }
 
-  if (x_node->remote_.type_ == RemoteFileLocation::Type::Full &&
-      y_node->remote_.type_ == RemoteFileLocation::Type::Full &&
+  if (x_node->remote_.type() == RemoteFileLocation::Type::Full &&
+      y_node->remote_.type() == RemoteFileLocation::Type::Full &&
       x_node->remote_.full().get_dc_id() != y_node->remote_.full().get_dc_id()) {
     LOG(ERROR) << "File remote location was changed from " << y_node->remote_.full() << " to "
                << x_node->remote_.full();
@@ -884,8 +884,8 @@ Result<FileId> FileManager::merge(FileId x_file_id, FileId y_file_id, bool no_sy
                                   << y_node->size_);
   }
   if (encryption_key_i == -1) {
-    if (nodes[remote_i]->remote_.type_ == RemoteFileLocation::Type::Full &&
-        nodes[local_i]->local_.type_ != LocalFileLocation::Type::Partial) {
+    if (nodes[remote_i]->remote_.type() == RemoteFileLocation::Type::Full &&
+        nodes[local_i]->local_.type() != LocalFileLocation::Type::Partial) {
       //???
       LOG(ERROR) << "Different encryption key in files, but go Choose same key as remote location";
       encryption_key_i = remote_i;
@@ -1105,19 +1105,19 @@ void FileManager::flush_to_pmc(FileNode *node, bool new_remote, bool new_local,
   FileData data;
   data.pmc_id_ = node->pmc_id_;
   data.local_ = node->local_;
-  if (data.local_.type_ == LocalFileLocation::Type::Full) {
-    prepare_path_for_pmc(data.local_.full().type_, data.local_.full().path_);
+  if (data.local_.type() == LocalFileLocation::Type::Full) {
+    prepare_path_for_pmc(data.local_.full().file_type_, data.local_.full().path_);
   }
   data.remote_ = node->remote_;
   data.generate_ = node->generate_;
 
-  if (data.generate_.type_ == GenerateFileLocation::Type::Full &&
+  if (data.generate_.type() == GenerateFileLocation::Type::Full &&
       begins_with(data.generate_.full().conversion_, "#file_id#")) {
     data.generate_ = GenerateFileLocation();
   }
 
   // TODO: not needed when GenerateLocation has constant convertion
-  if (data.remote_.type_ != RemoteFileLocation::Type::Full && data.local_.type_ != LocalFileLocation::Type::Full) {
+  if (data.remote_.type() != RemoteFileLocation::Type::Full && data.local_.type() != LocalFileLocation::Type::Full) {
     data.local_ = LocalFileLocation();
     data.remote_ = RemoteFileLocation();
   }
@@ -1182,7 +1182,7 @@ bool FileManager::load_from_pmc(FileNode *node, bool new_remote, bool new_local,
   new_local &= file_view.has_local_location();
   if (new_local) {
     local = get_file_view(file_id).local_location();
-    prepare_path_for_pmc(local.type_, local.path_);
+    prepare_path_for_pmc(local.file_type_, local.path_);
   }
   new_generate &= file_view.has_generate_location();
   if (new_generate) {
@@ -1230,7 +1230,7 @@ bool FileManager::set_content(FileId file_id, BufferSlice bytes) {
     return false;
   }
 
-  if (node->local_.type_ == LocalFileLocation::Type::Full) {
+  if (node->local_.type() == LocalFileLocation::Type::Full) {
     // There was no download so we don't need an update
     return true;
   }
@@ -1249,7 +1249,7 @@ bool FileManager::set_content(FileId file_id, BufferSlice bytes) {
   QueryId id = queries_container_.create(Query{file_id, Query::SetContent});
   node->download_id_ = id;
   node->is_download_started_ = true;
-  send_closure(file_load_manager_, &FileLoadManager::from_bytes, id, node->remote_.full().type_, std::move(bytes),
+  send_closure(file_load_manager_, &FileLoadManager::from_bytes, id, node->remote_.full().file_type_, std::move(bytes),
                node->name_);
   return true;
 }
@@ -1294,7 +1294,7 @@ void FileManager::delete_file(FileId file_id, Promise<Unit> promise, const char
     if (file_view.get_type() == FileType::Encrypted) {
       clear_from_pmc(node);
     }
-    if (node->local_.type_ == LocalFileLocation::Type::Partial) {
+    if (node->local_.type() == LocalFileLocation::Type::Partial) {
       LOG(INFO) << "Unlink partial file " << file_id << " at " << node->local_.partial().path_;
       unlink(node->local_.partial().path_).ignore();
       node->set_local_location(LocalFileLocation(), 0);
@@ -1314,7 +1314,7 @@ void FileManager::download(FileId file_id, std::shared_ptr<DownloadCallback> cal
     return;
   }
 
-  if (node->local_.type_ == LocalFileLocation::Type::Full) {
+  if (node->local_.type() == LocalFileLocation::Type::Full) {
     auto status = check_local_location(node);
     if (status.is_error()) {
       LOG(WARNING) << "Need to redownload file " << file_id << ": " << status.error();
@@ -1324,7 +1324,7 @@ void FileManager::download(FileId file_id, std::shared_ptr<DownloadCallback> cal
       }
       return;
     }
-  } else if (node->local_.type_ == LocalFileLocation::Type::Partial) {
+  } else if (node->local_.type() == LocalFileLocation::Type::Partial) {
     auto status = check_local_location(node);
     if (status.is_error()) {
       LOG(WARNING) << "Need to download file " << file_id << " from beginning: " << status.error();
@@ -1461,7 +1461,7 @@ bool FileManager::delete_partial_remote_location(FileId file_id) {
   if (node->upload_pause_ == file_id) {
     node->upload_pause_ = FileId();
   }
-  if (node->remote_.type_ == RemoteFileLocation::Type::Full) {
+  if (node->remote_.type() == RemoteFileLocation::Type::Full) {
     LOG(INFO) << "File " << file_id << " is already uploaded";
     return true;
   }
@@ -1470,7 +1470,7 @@ bool FileManager::delete_partial_remote_location(FileId file_id) {
   auto *file_info = get_file_id_info(file_id);
   file_info->upload_priority_ = 0;
 
-  if (node->local_.type_ != LocalFileLocation::Type::Full) {
+  if (node->local_.type() != LocalFileLocation::Type::Full) {
     LOG(INFO) << "Need full local location to upload file " << file_id;
     return false;
   }
@@ -1603,8 +1603,8 @@ void FileManager::run_upload(FileNode *node, std::vector<int> bad_parts) {
   }
 
   // create encryption key if necessary
-  if (((file_view.has_generate_location() && file_view.generate_location().type_ == FileType::Encrypted) ||
-       (file_view.has_local_location() && file_view.local_location().type_ == FileType::Encrypted)) &&
+  if (((file_view.has_generate_location() && file_view.generate_location().file_type_ == FileType::Encrypted) ||
+       (file_view.has_local_location() && file_view.local_location().file_type_ == FileType::Encrypted)) &&
       file_view.encryption_key().empty()) {
     CHECK(!node->file_ids_.empty());
     bool success = set_encryption_key(node->file_ids_[0], FileEncryptionKey::create());
@@ -1619,7 +1619,7 @@ void FileManager::run_upload(FileNode *node, std::vector<int> bad_parts) {
   }
 
   CHECK(node->upload_id_ == 0);
-  if (node->remote_.type_ != RemoteFileLocation::Type::Partial && node->get_by_hash_) {
+  if (node->remote_.type() != RemoteFileLocation::Type::Partial && node->get_by_hash_) {
     QueryId id = queries_container_.create(Query{file_id, Query::UploadByHash});
     node->upload_id_ = id;
 
@@ -1726,10 +1726,10 @@ Result<FileId> FileManager::from_persistent_id(CSlice persistent_id, FileType fi
   if (status.is_error()) {
     return Status::Error(10, "Wrong remote file id specified: can't unserialize it");
   }
-  auto &real_type = remote_location.type_;
-  if (is_document_type(real_type) && is_document_type(file_type)) {
-    real_type = file_type;
-  } else if (real_type != file_type && file_type != FileType::Temp) {
+  auto &real_file_type = remote_location.file_type_;
+  if (is_document_type(real_file_type) && is_document_type(file_type)) {
+    real_file_type = file_type;
+  } else if (real_file_type != file_type && file_type != FileType::Temp) {
     return Status::Error(10, "Type of file mismatch");
   }
   FileData data;
@@ -2173,12 +2173,12 @@ void FileManager::on_error_impl(FileNode *node, FileManager::Query::Type type, b
                  << ". File type is " << file_type_name[static_cast<int32>(FileView(node).get_type())];
     if (status.code() == 0) {
       // Remove partial locations
-      if (node->local_.type_ == LocalFileLocation::Type::Partial) {
+      if (node->local_.type() == LocalFileLocation::Type::Partial) {
         LOG(INFO) << "Unlink file " << node->local_.partial().path_;
         unlink(node->local_.partial().path_).ignore();
         node->set_local_location(LocalFileLocation(), 0);
       }
-      if (node->remote_.type_ == RemoteFileLocation::Type::Partial) {
+      if (node->remote_.type() == RemoteFileLocation::Type::Partial) {
         node->set_remote_location(RemoteFileLocation(), FileLocationSource::None, 0);
       }
       status = Status::Error(400, status.message());
diff --git a/td/telegram/files/FileManager.h b/td/telegram/files/FileManager.h
index 21e1cc6d..880fd553 100644
--- a/td/telegram/files/FileManager.h
+++ b/td/telegram/files/FileManager.h
@@ -166,13 +166,13 @@ class FileView {
 
   FileType get_type() const {
     if (has_local_location()) {
-      return local_location().type_;
+      return local_location().file_type_;
     }
     if (has_remote_location()) {
-      return remote_location().type_;
+      return remote_location().file_type_;
     }
     if (has_generate_location()) {
-      return generate_location().type_;
+      return generate_location().file_type_;
     }
     return FileType::Temp;
   }
diff --git a/td/telegram/files/FileManager.hpp b/td/telegram/files/FileManager.hpp
index cd4d4720..94e7f4df 100644
--- a/td/telegram/files/FileManager.hpp
+++ b/td/telegram/files/FileManager.hpp
@@ -160,7 +160,7 @@ FileId FileManager::parse_file(ParserT &parser) {
           return r_file_id.move_as_ok();
         }
         LOG(ERROR) << "Can't resend local file " << full_local_location.path_;
-        return register_empty(full_local_location.type_);
+        return register_empty(full_local_location.file_type_);
       }
       case FileStoreType::Generate: {
         FullGenerateFileLocation full_generated_location;
@@ -175,23 +175,23 @@ FileId FileManager::parse_file(ParserT &parser) {
         }
         if (begins_with(full_generated_location.conversion_, "#file_id#")) {
           LOG(ERROR) << "Can't resend message with '#file_id#...' location";
-          return register_empty(full_generated_location.type_);
+          return register_empty(full_generated_location.file_type_);
         }
         if (full_generated_location.conversion_ == "#_file_id#") {
           auto file_id = parse_file(parser);
           if (file_id.empty()) {
-            return register_empty(full_generated_location.type_);
+            return register_empty(full_generated_location.file_type_);
           }
           auto download_file_id = dup_file_id(file_id);
           full_generated_location.conversion_ = PSTRING() << "#file_id#" << download_file_id.get();
         }
 
-        auto r_file_id = register_generate(full_generated_location.type_, full_generated_location.original_path_,
+        auto r_file_id = register_generate(full_generated_location.file_type_, full_generated_location.original_path_,
                                            full_generated_location.conversion_, owner_dialog_id, expected_size);
         if (r_file_id.is_ok()) {
           return r_file_id.move_as_ok();
         }
-        return register_empty(full_generated_location.type_);
+        return register_empty(full_generated_location.file_type_);
       }
       case FileStoreType::Url: {
         FileType type;
diff --git a/td/telegram/files/FileStatsWorker.cpp b/td/telegram/files/FileStatsWorker.cpp
index 0ad75119..d45a8d6b 100644
--- a/td/telegram/files/FileStatsWorker.cpp
+++ b/td/telegram/files/FileStatsWorker.cpp
@@ -54,11 +54,11 @@ Status scan_db(CallbackT &&callback) {
       return;
     }
     DbFileInfo info;
-    if (data.local_.type_ == LocalFileLocation::Type::Full) {
-      info.file_type = data.local_.full().type_;
+    if (data.local_.type() == LocalFileLocation::Type::Full) {
+      info.file_type = data.local_.full().file_type_;
       info.path = data.local_.full().path_;
-    } else if (data.local_.type_ == LocalFileLocation::Type::Partial) {
-      info.file_type = data.local_.partial().type_;
+    } else if (data.local_.type() == LocalFileLocation::Type::Partial) {
+      info.file_type = data.local_.partial().file_type_;
       info.path = data.local_.partial().path_;
     } else {
       return;
@@ -69,7 +69,7 @@ Status scan_db(CallbackT &&callback) {
     }
     info.owner_dialog_id = data.owner_dialog_id_;
     info.size = data.size_;
-    if (info.size == 0 && data.local_.type_ == LocalFileLocation::Type::Full) {
+    if (info.size == 0 && data.local_.type() == LocalFileLocation::Type::Full) {
       LOG(ERROR) << "Unknown size in db";
       return;
     }
diff --git a/td/telegram/files/FileUploader.cpp b/td/telegram/files/FileUploader.cpp
index 4f8658b7..7c99b58d 100644
--- a/td/telegram/files/FileUploader.cpp
+++ b/td/telegram/files/FileUploader.cpp
@@ -36,7 +36,7 @@ FileUploader::FileUploader(const LocalFileLocation &local, const RemoteFileLocat
 }
 
 Result<FileLoader::FileInfo> FileUploader::init() {
-  if (remote_.type_ == RemoteFileLocation::Type::Full) {
+  if (remote_.type() == RemoteFileLocation::Type::Full) {
     return Status::Error("File is already uploaded");
   }
 
@@ -45,7 +45,7 @@ Result<FileLoader::FileInfo> FileUploader::init() {
 
   int offset = 0;
   int part_size = 0;
-  if (remote_.type_ == RemoteFileLocation::Type::Partial) {
+  if (remote_.type() == RemoteFileLocation::Type::Partial) {
     const auto &partial = remote_.partial();
     file_id_ = partial.file_id_;
     part_size = partial.part_size_;
@@ -87,20 +87,20 @@ Result<FileLoader::PrefixInfo> FileUploader::on_update_local_location(const Loca
   int64 local_size = 0;
   bool local_is_ready{false};
   FileType file_type{FileType::Temp};
-  if (location.type_ == LocalFileLocation::Type::Empty) {
+  if (location.type() == LocalFileLocation::Type::Empty) {
     path = "";
     local_size = 0;
     local_is_ready = false;
     file_type = FileType::Temp;
-  } else if (location.type_ == LocalFileLocation::Type::Partial) {
+  } else if (location.type() == LocalFileLocation::Type::Partial) {
     path = location.partial().path_;
     local_size = static_cast<int64>(location.partial().part_size_) * location.partial().ready_part_count_;
     local_is_ready = false;
-    file_type = location.partial().type_;
+    file_type = location.partial().file_type_;
   } else {
     path = location.full().path_;
     local_is_ready = true;
-    file_type = location.full().type_;
+    file_type = location.full().file_type_;
   }
 
   if (!path.empty() && path != fd_path_) {
@@ -108,7 +108,7 @@ Result<FileLoader::PrefixInfo> FileUploader::on_update_local_location(const Loca
 
     // Race: partial location could be already deleted. Just ignore such locations
     if (res_fd.is_error()) {
-      if (location.type_ == LocalFileLocation::Type::Partial) {
+      if (location.type() == LocalFileLocation::Type::Partial) {
         PrefixInfo info;
         info.size = local_size_;
         info.is_ready = local_is_ready_;