ApiWrap(

base::weak_qptr<MTP::Instance> weak,

Fn<void(FnMut<void()>)> runner);

rpl::producer<MTP::Error> errors() const;

rpl::producer<Output::Result> ioErrors() const;

struct StartInfo {

int userpicsCount = 0;

int storiesCount = 0;

int profileMusicCount = 0;

int dialogsCount = 0;

};

void startExport(

const Settings &settings,

Output::Stats *stats,

FnMut<void(StartInfo)> done);

void requestDialogsList(

Fn<bool(int count)> progress,

FnMut<void(Data::DialogsInfo&&)> done);

void requestPersonalInfo(FnMut<void(Data::PersonalInfo&&)> done);

void requestOtherData(

const QString &suggestedPath,

FnMut<void(Data::File&&)> done);

struct DownloadProgress {

uint64 randomId = 0;

QString path;

int itemIndex = 0;

int64 ready = 0;

int64 total = 0;

};

void requestUserpics(

FnMut<bool(Data::UserpicsInfo&&)> start,

Fn<bool(DownloadProgress)> progress,

Fn<bool(Data::UserpicsSlice&&)> slice,

FnMut<void()> finish);

void requestStories(

FnMut<bool(Data::StoriesInfo&&)> start,

Fn<bool(DownloadProgress)> progress,

Fn<bool(Data::StoriesSlice&&)> slice,

FnMut<void()> finish);

void requestProfileMusic(

FnMut<bool(Data::ProfileMusicInfo&&)> start,

Fn<bool(DownloadProgress)> progress,

Fn<bool(Data::ProfileMusicSlice&&)> slice,

FnMut<void()> finish);

void requestContacts(FnMut<void(Data::ContactsList&&)> done);

void requestSessions(FnMut<void(Data::SessionsList&&)> done);

void requestMessages(

const Data::DialogInfo &info,

FnMut<bool(const Data::DialogInfo &)> start,

Fn<bool(DownloadProgress)> progress,

Fn<bool(Data::MessagesSlice&&)> slice,

FnMut<void()> done);

void requestTopicMessages(

PeerId peerId,

MTPInputPeer inputPeer,

int32 topicRootId,

FnMut<bool(int count)> start,

Fn<bool(DownloadProgress)> progress,

Fn<bool(Data::MessagesSlice&&)> slice,

FnMut<void()> done);

void finishExport(FnMut<void()> done);

void skipFile(uint64 randomId);

void cancelExportFast();

~ApiWrap();

class LoadedFileCache;

struct StartProcess;

struct ContactsProcess;

struct UserpicsProcess;

struct StoriesProcess;

struct ProfileMusicProcess;

struct OtherDataProcess;

struct FileProcess;

struct FileProgress;

struct FilePolicy;

struct MessageFileWork;

struct ChatsProcess;

struct LeftChannelsProcess;

struct DialogsProcess;

struct AbstractMessagesProcess;

struct ChatProcess;

struct TopicProcess;

void startMainSession(FnMut<void()> done);

void sendNextStartRequest();

void requestUserpicsCount();

void requestStoriesCount();

void requestProfileMusicCount();

void requestSplitRanges();

void requestDialogsCount();

void requestLeftChannelsCount();

void finishStartProcess();

void requestTopPeersSlice();

void handleUserpicsSlice(const MTPphotos_Photos &result);

void loadUserpicsFiles(Data::UserpicsSlice &&slice);

void loadNextUserpic();

bool loadUserpicProgress(FileProgress value);

void loadUserpicDone(const QString &relativePath);

void finishUserpicsSlice();

void finishUserpics();

void handleStoriesSlice(const MTPstories_Stories &result);

void loadStoriesFiles(Data::StoriesSlice &&slice);

void loadNextStory();

bool loadStoryProgress(FileProgress value);

void loadStoryDone(const QString &relativePath);

bool loadStoryThumbProgress(FileProgress value);

void loadStoryThumbDone(const QString &relativePath);

void finishStoriesSlice();

void finishStories();

void handleProfileMusicSlice(const MTPusers_SavedMusic &result);

void loadProfileMusicFiles(Data::ProfileMusicSlice &&slice);

void loadNextProfileMusic();

bool loadProfileMusicProgress(FileProgress value);

void loadProfileMusicDone(const QString &relativePath);

bool loadProfileMusicThumbProgress(FileProgress value);

void loadProfileMusicThumbDone(const QString &relativePath);

void finishProfileMusicSlice();

void finishProfileMusic();

void otherDataDone(const QString &relativePath);

bool useOnlyLastSplit() const;

void requestDialogsSlice();

void appendDialogsSlice(Data::DialogsInfo &&info);

void finishDialogsList();

void requestSinglePeerDialog();

mtpRequestId requestSinglePeerMigrated(const Data::DialogInfo &info);

void appendSinglePeerDialogs(Data::DialogsInfo &&info);

void requestLeftChannelsIfNeeded();

void requestLeftChannelsList(

Fn<bool(int count)> progress,

FnMut<void(Data::DialogsInfo&&)> done);

void requestLeftChannelsSliceGeneric(FnMut<void()> done);

void requestLeftChannelsSlice();

void appendLeftChannelsSlice(Data::DialogsInfo &&info);

void appendChatsSlice(

ChatsProcess &process,

std::vector<Data::DialogInfo> &to,

std::vector<Data::DialogInfo> &&from,

int splitIndex);

void requestMessagesCount(int localSplitIndex);

void checkFirstMessageDate(int localSplitIndex, int count);

void messagesCountLoaded(int localSplitIndex, int count);

void requestMessagesSlice();

void requestChatMessages(

int splitIndex,

int offsetId,

int addOffset,

int limit,

FnMut<void(MTPmessages_Messages&&)> done);

void startMessagesSlice(Data::MessagesSlice &&slice);

void resumeMessagesSlice();

void hydrateMessageDone(

bool topic,

int index,

int32 rawId,

const MTPmessages_Messages &result);

void requestTopicMessagesSlice();

void requestTopicReplies(

int offsetId,

int addOffset,

int limit,

FnMut<void(MTPmessages_Messages&&)> done);

void collectMessagesCustomEmoji(const Data::MessagesSlice &slice);

void resolveCustomEmoji();

void buildMessageFileWork(

AbstractMessagesProcess &process,

Data::Message &message);

void loadNextMessageFile();

[[nodiscard]] std::optional<QByteArray> getCustomEmoji(

Data::Message &message,

QByteArray &data);

bool messageCustomEmojiReady(Data::Message &message);

bool loadMessageFileProgress(int index, FileProgress value);

void loadMessageFileDone(

int index,

Data::File *file,

const QString &relativePath);

bool loadMessageEmojiProgress(FileProgress progress);

void loadMessageEmojiDone(uint64 id, const QString &relativePath);

void finishMessagesSlice();

void finishMessages();

void loadTopicMessagesFiles(Data::MessagesSlice &&slice);

void resolveTopicCustomEmoji();

void loadNextTopicMessageFile();

bool loadTopicMessageFileProgress(int index, FileProgress value);

void loadTopicMessageFileDone(

int index,

Data::File *file,

const QString &relativePath);

bool loadTopicEmojiProgress(FileProgress progress);

void loadCustomEmojiDone(uint64 id, const QString &relativePath);

void finishTopicMessagesSlice();

void finishTopicMessages();

[[nodiscard]] Data::Message *currentFileMessage() const;

[[nodiscard]] Data::FileOrigin currentFileMessageOrigin() const;

bool processFileLoad(

Data::File &file,

const Data::FileOrigin &origin,

Fn<bool(FileProgress)> progress,

FnMut<void(QString)> done,

const FilePolicy &policy);

bool processFileLoad(

Data::File &file,

const Data::FileOrigin &origin,

Fn<bool(FileProgress)> progress,

FnMut<void(QString)> done,

Data::Message *message = nullptr,

Data::Story *story = nullptr);

std::unique_ptr<FileProcess> prepareFileProcess(

const Data::File &file,

const Data::FileOrigin &origin) const;

bool writePreloadedFile(

Data::File &file,

const Data::FileOrigin &origin);

void loadFile(

const Data::File &file,

const Data::FileOrigin &origin,

Fn<bool(FileProgress)> progress,

FnMut<void(QString)> done);

void loadFilePart();

void filePartDone(int64 offset, const MTPupload_File &result);

void filePartUnavailable();

[[nodiscard]] QString filePartMediaFolder() const;

void filePartRetryReference(

int64 offset,

Data::FileLocation location);

void filePartRefreshReference(int64 offset);

void filePartExtractCustomEmojiReference(

int64 offset,

uint64 customEmojiId,

const QString &folder,

const MTPVector<MTPDocument> &result);

void filePartExtractRichReference(

int64 offset,

const Data::FileOrigin &origin,

const QString &folder,

const MTPmessages_Messages &result);

void filePartExtractReference(

int64 offset,

const MTPmessages_Messages &result);

void filePartExtractReference(

int64 offset,

const MTPstories_Stories &result);

template <typename Request>

class RequestBuilder;

template <typename Request>

[[nodiscard]] auto mainRequest(Request &&request);

template <typename Request>

[[nodiscard]] auto splitRequest(int index, Request &&request);

[[nodiscard]] auto fileRequest(

const Data::FileLocation &location,

int64 offset);

void error(const MTP::Error &error);

void error(const QString &text);

void ioError(const Output::Result &result);

MTP::ConcurrentSender _mtp;

std::optional<uint64> _takeoutId;

std::optional<UserId> _selfId;

Output::Stats *_stats = nullptr;

std::unique_ptr<Settings> _settings;

MTPInputUser _user = MTP_inputUserSelf();

std::unique_ptr<StartProcess> _startProcess;

std::unique_ptr<LoadedFileCache> _fileCache;

std::unique_ptr<ContactsProcess> _contactsProcess;

std::unique_ptr<UserpicsProcess> _userpicsProcess;

std::unique_ptr<StoriesProcess> _storiesProcess;

std::unique_ptr<ProfileMusicProcess> _profileMusicProcess;

std::unique_ptr<OtherDataProcess> _otherDataProcess;

std::unique_ptr<FileProcess> _fileProcess;

std::unique_ptr<LeftChannelsProcess> _leftChannelsProcess;

std::unique_ptr<DialogsProcess> _dialogsProcess;

std::unique_ptr<ChatProcess> _chatProcess;

std::unique_ptr<TopicProcess> _topicProcess;

base::flat_set<uint64> _unresolvedCustomEmoji;

base::flat_map<uint64, Data::Document> _resolvedCustomEmoji;

QVector<MTPMessageRange> _splits;

rpl::event_stream<MTP::Error> _errors;

rpl::event_stream<Output::Result> _ioErrors;