Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramCore/Sources/TelegramEngine/Data/ChatListData.swift

@@ -0,0 +1,25 @@
+import SwiftSignalKit
+import Postbox
+
+public extension TelegramEngine.EngineData.Item {
+    enum ChatList {
+        public struct FiltersDisplayTags: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = Bool
+
+            public init() {
+            }
+
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.chatListFilters]))
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                let state = view.values[PreferencesKeys.chatListFilters]?.get(ChatListFiltersState.self) ?? ChatListFiltersState.default
+                return state.displayTags
+            }
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Data/ConfigurationData.swift

@@ -0,0 +1,575 @@
+import SwiftSignalKit
+import Postbox
+
+public enum EngineConfiguration {
+    public struct Limits: Equatable {
+        public static let timeIntervalForever: Int32 = 0x7fffffff
+        
+        public var maxGroupMemberCount: Int32
+        public var maxSupergroupMemberCount: Int32
+        public var maxMessageForwardBatchSize: Int32
+        public var maxRecentStickerCount: Int32
+        public var maxMessageEditingInterval: Int32
+        public var canRemoveIncomingMessagesInPrivateChats: Bool
+        public var maxMessageRevokeInterval: Int32
+        public var maxMessageRevokeIntervalInPrivateChats: Int32
+
+        public init(
+            maxGroupMemberCount: Int32,
+            maxSupergroupMemberCount: Int32,
+            maxMessageForwardBatchSize: Int32,
+            maxRecentStickerCount: Int32,
+            maxMessageEditingInterval: Int32,
+            canRemoveIncomingMessagesInPrivateChats: Bool,
+            maxMessageRevokeInterval: Int32,
+            maxMessageRevokeIntervalInPrivateChats: Int32
+        ) {
+            self.maxGroupMemberCount = maxGroupMemberCount
+            self.maxSupergroupMemberCount = maxSupergroupMemberCount
+            self.maxMessageForwardBatchSize = maxMessageForwardBatchSize
+            self.maxRecentStickerCount = maxRecentStickerCount
+            self.maxMessageEditingInterval = maxMessageEditingInterval
+            self.canRemoveIncomingMessagesInPrivateChats = canRemoveIncomingMessagesInPrivateChats
+            self.maxMessageRevokeInterval = maxMessageRevokeInterval
+            self.maxMessageRevokeIntervalInPrivateChats = maxMessageRevokeIntervalInPrivateChats
+        }
+    }
+    
+    public struct UserLimits: Equatable {
+        public let maxPinnedChatCount: Int32
+        public let maxPinnedSavedChatCount: Int32
+        public let maxArchivedPinnedChatCount: Int32
+        public let maxChannelsCount: Int32
+        public let maxPublicLinksCount: Int32
+        public let maxSavedGifCount: Int32
+        public let maxFavedStickerCount: Int32
+        public let maxFoldersCount: Int32
+        public let maxFolderChatsCount: Int32
+        public let maxCaptionLength: Int32
+        public let maxUploadFileParts: Int32
+        public let maxAboutLength: Int32
+        public let maxAnimatedEmojisInText: Int32
+        public let maxReactionsPerMessage: Int32
+        public let maxSharedFolderInviteLinks: Int32
+        public let maxSharedFolderJoin: Int32
+        public let maxStoryCaptionLength: Int32
+        public let maxExpiringStoriesCount: Int32
+        public let maxStoriesWeeklyCount: Int32
+        public let maxStoriesMonthlyCount: Int32
+        public let maxStoriesSuggestedReactions: Int32
+        public let maxStoriesLinksCount: Int32
+        public let maxGiveawayChannelsCount: Int32
+        public let maxGiveawayCountriesCount: Int32
+        public let maxGiveawayPeriodSeconds: Int32
+        public let maxChannelRecommendationsCount: Int32
+        public let maxConferenceParticipantCount: Int32
+        
+        public static var defaultValue: UserLimits {
+            return UserLimits(UserLimitsConfiguration.defaultValue)
+        }
+
+        public init(
+            maxPinnedChatCount: Int32,
+            maxPinnedSavedChatCount: Int32,
+            maxArchivedPinnedChatCount: Int32,
+            maxChannelsCount: Int32,
+            maxPublicLinksCount: Int32,
+            maxSavedGifCount: Int32,
+            maxFavedStickerCount: Int32,
+            maxFoldersCount: Int32,
+            maxFolderChatsCount: Int32,
+            maxCaptionLength: Int32,
+            maxUploadFileParts: Int32,
+            maxAboutLength: Int32,
+            maxAnimatedEmojisInText: Int32,
+            maxReactionsPerMessage: Int32,
+            maxSharedFolderInviteLinks: Int32,
+            maxSharedFolderJoin: Int32,
+            maxStoryCaptionLength: Int32,
+            maxExpiringStoriesCount: Int32,
+            maxStoriesWeeklyCount: Int32,
+            maxStoriesMonthlyCount: Int32,
+            maxStoriesSuggestedReactions: Int32,
+            maxStoriesLinksCount: Int32,
+            maxGiveawayChannelsCount: Int32,
+            maxGiveawayCountriesCount: Int32,
+            maxGiveawayPeriodSeconds: Int32,
+            maxChannelRecommendationsCount: Int32,
+            maxConferenceParticipantCount: Int32
+        ) {
+            self.maxPinnedChatCount = maxPinnedChatCount
+            self.maxPinnedSavedChatCount = maxPinnedSavedChatCount
+            self.maxArchivedPinnedChatCount = maxArchivedPinnedChatCount
+            self.maxChannelsCount = maxChannelsCount
+            self.maxPublicLinksCount = maxPublicLinksCount
+            self.maxSavedGifCount = maxSavedGifCount
+            self.maxFavedStickerCount = maxFavedStickerCount
+            self.maxFoldersCount = maxFoldersCount
+            self.maxFolderChatsCount = maxFolderChatsCount
+            self.maxCaptionLength = maxCaptionLength
+            self.maxUploadFileParts = maxUploadFileParts
+            self.maxAboutLength = maxAboutLength
+            self.maxAnimatedEmojisInText = maxAnimatedEmojisInText
+            self.maxReactionsPerMessage = maxReactionsPerMessage
+            self.maxSharedFolderInviteLinks = maxSharedFolderInviteLinks
+            self.maxSharedFolderJoin = maxSharedFolderJoin
+            self.maxStoryCaptionLength = maxStoryCaptionLength
+            self.maxExpiringStoriesCount = maxExpiringStoriesCount
+            self.maxStoriesWeeklyCount = maxStoriesWeeklyCount
+            self.maxStoriesMonthlyCount = maxStoriesMonthlyCount
+            self.maxStoriesSuggestedReactions = maxStoriesSuggestedReactions
+            self.maxStoriesLinksCount = maxStoriesLinksCount
+            self.maxGiveawayChannelsCount = maxGiveawayChannelsCount
+            self.maxGiveawayCountriesCount = maxGiveawayCountriesCount
+            self.maxGiveawayPeriodSeconds = maxGiveawayPeriodSeconds
+            self.maxChannelRecommendationsCount = maxChannelRecommendationsCount
+            self.maxConferenceParticipantCount = maxConferenceParticipantCount
+        }
+    }
+}
+
+public typealias EngineContentSettings = ContentSettings
+
+public extension EngineConfiguration.Limits {
+    init(_ limitsConfiguration: LimitsConfiguration) {
+        self.init(
+            maxGroupMemberCount: limitsConfiguration.maxGroupMemberCount,
+            maxSupergroupMemberCount: limitsConfiguration.maxSupergroupMemberCount,
+            maxMessageForwardBatchSize: limitsConfiguration.maxMessageForwardBatchSize,
+            maxRecentStickerCount: limitsConfiguration.maxRecentStickerCount,
+            maxMessageEditingInterval: limitsConfiguration.maxMessageEditingInterval,
+            canRemoveIncomingMessagesInPrivateChats: limitsConfiguration.canRemoveIncomingMessagesInPrivateChats,
+            maxMessageRevokeInterval: limitsConfiguration.maxMessageRevokeInterval,
+            maxMessageRevokeIntervalInPrivateChats: limitsConfiguration.maxMessageRevokeIntervalInPrivateChats
+        )
+    }
+    
+    func _asLimits() -> LimitsConfiguration {
+        return LimitsConfiguration(
+            maxGroupMemberCount: self.maxGroupMemberCount,
+            maxSupergroupMemberCount: self.maxSupergroupMemberCount,
+            maxMessageForwardBatchSize: self.maxMessageForwardBatchSize,
+            maxRecentStickerCount: self.maxRecentStickerCount,
+            maxMessageEditingInterval: self.maxMessageEditingInterval,
+            canRemoveIncomingMessagesInPrivateChats: self.canRemoveIncomingMessagesInPrivateChats,
+            maxMessageRevokeInterval: self.maxMessageRevokeInterval,
+            maxMessageRevokeIntervalInPrivateChats: self.maxMessageRevokeIntervalInPrivateChats
+        )
+    }
+}
+
+public extension EngineConfiguration.UserLimits {
+    init(_ userLimitsConfiguration: UserLimitsConfiguration) {
+        self.init(
+            maxPinnedChatCount: userLimitsConfiguration.maxPinnedChatCount,
+            maxPinnedSavedChatCount: userLimitsConfiguration.maxPinnedSavedChatCount,
+            maxArchivedPinnedChatCount: userLimitsConfiguration.maxArchivedPinnedChatCount,
+            maxChannelsCount: userLimitsConfiguration.maxChannelsCount,
+            maxPublicLinksCount: userLimitsConfiguration.maxPublicLinksCount,
+            maxSavedGifCount: userLimitsConfiguration.maxSavedGifCount,
+            maxFavedStickerCount: userLimitsConfiguration.maxFavedStickerCount,
+            maxFoldersCount: userLimitsConfiguration.maxFoldersCount,
+            maxFolderChatsCount: userLimitsConfiguration.maxFolderChatsCount,
+            maxCaptionLength: userLimitsConfiguration.maxCaptionLength,
+            maxUploadFileParts: userLimitsConfiguration.maxUploadFileParts,
+            maxAboutLength: userLimitsConfiguration.maxAboutLength,
+            maxAnimatedEmojisInText: userLimitsConfiguration.maxAnimatedEmojisInText,
+            maxReactionsPerMessage: userLimitsConfiguration.maxReactionsPerMessage,
+            maxSharedFolderInviteLinks: userLimitsConfiguration.maxSharedFolderInviteLinks,
+            maxSharedFolderJoin: userLimitsConfiguration.maxSharedFolderJoin,
+            maxStoryCaptionLength: userLimitsConfiguration.maxStoryCaptionLength,
+            maxExpiringStoriesCount: userLimitsConfiguration.maxExpiringStoriesCount,
+            maxStoriesWeeklyCount: userLimitsConfiguration.maxStoriesWeeklyCount,
+            maxStoriesMonthlyCount: userLimitsConfiguration.maxStoriesMonthlyCount,
+            maxStoriesSuggestedReactions: userLimitsConfiguration.maxStoriesSuggestedReactions,
+            maxStoriesLinksCount: userLimitsConfiguration.maxStoriesLinksCount,
+            maxGiveawayChannelsCount: userLimitsConfiguration.maxGiveawayChannelsCount,
+            maxGiveawayCountriesCount: userLimitsConfiguration.maxGiveawayCountriesCount,
+            maxGiveawayPeriodSeconds: userLimitsConfiguration.maxGiveawayPeriodSeconds,
+            maxChannelRecommendationsCount: userLimitsConfiguration.maxChannelRecommendationsCount,
+            maxConferenceParticipantCount: userLimitsConfiguration.maxConferenceParticipantCount
+        )
+    }
+}
+
+public extension EngineConfiguration {
+    struct SearchBots {
+        public var imageBotUsername: String?
+        public var gifBotUsername: String?
+        public var venueBotUsername: String?
+        
+        public init(
+            imageBotUsername: String?,
+            gifBotUsername: String?,
+            venueBotUsername: String?
+        ) {
+            self.imageBotUsername = imageBotUsername
+            self.gifBotUsername = gifBotUsername
+            self.venueBotUsername = venueBotUsername
+        }
+    }
+}
+
+public extension EngineConfiguration.SearchBots {
+    init(_ configuration: SearchBotsConfiguration) {
+        self.init(
+            imageBotUsername: configuration.imageBotUsername,
+            gifBotUsername: configuration.gifBotUsername,
+            venueBotUsername: configuration.venueBotUsername
+        )
+    }
+}
+
+public extension EngineConfiguration {
+    struct Links {
+        public var autologinToken: String?
+
+        public init(
+            autologinToken: String?
+        ) {
+            self.autologinToken = autologinToken
+        }
+    }
+}
+
+public extension EngineConfiguration.Links {
+    init(_ configuration: LinksConfiguration) {
+        self.init(
+            autologinToken: configuration.autologinToken
+        )
+    }
+}
+
+public extension TelegramEngine.EngineData.Item {
+    enum Configuration {
+        public struct App: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = AppConfiguration
+
+            public init() {
+            }
+
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.appConfiguration]))
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let appConfiguration = view.values[PreferencesKeys.appConfiguration]?.get(AppConfiguration.self) else {
+                    return AppConfiguration.defaultValue
+                }
+                return appConfiguration
+            }
+        }
+        
+        public struct Limits: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = EngineConfiguration.Limits
+
+            public init() {
+            }
+
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.limitsConfiguration]))
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let limitsConfiguration = view.values[PreferencesKeys.limitsConfiguration]?.get(LimitsConfiguration.self) else {
+                    return EngineConfiguration.Limits(LimitsConfiguration.defaultValue)
+                }
+                return EngineConfiguration.Limits(limitsConfiguration)
+            }
+        }
+        
+        public struct UserLimits: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = EngineConfiguration.UserLimits
+            
+            fileprivate let isPremium: Bool
+            public init(isPremium: Bool) {
+                self.isPremium = isPremium
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.appConfiguration]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let appConfiguration = view.values[PreferencesKeys.appConfiguration]?.get(AppConfiguration.self) else {
+                    return EngineConfiguration.UserLimits(UserLimitsConfiguration.defaultValue)
+                }
+                return EngineConfiguration.UserLimits(UserLimitsConfiguration(appConfiguration: appConfiguration, isPremium: self.isPremium))
+            }
+        }
+        
+        public struct SuggestedLocalization: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = SuggestedLocalizationEntry?
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.suggestedLocalization]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let suggestedLocalization = view.values[PreferencesKeys.suggestedLocalization]?.get(SuggestedLocalizationEntry.self) else {
+                    return nil
+                }
+                return suggestedLocalization
+            }
+        }
+
+        public struct SearchBots: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = EngineConfiguration.SearchBots
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.searchBotsConfiguration]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let value = view.values[PreferencesKeys.searchBotsConfiguration]?.get(SearchBotsConfiguration.self) else {
+                    return EngineConfiguration.SearchBots(SearchBotsConfiguration.defaultValue)
+                }
+                return EngineConfiguration.SearchBots(value)
+            }
+        }
+        
+        public struct ApplicationSpecificPreference: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = PreferencesEntry?
+            
+            private let itemKey: ValueBoxKey
+            public init(key: ValueBoxKey) {
+                self.itemKey = key
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([self.itemKey]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let value = view.values[self.itemKey] else {
+                    return nil
+                }
+                return value
+            }
+        }
+        
+        public struct ContentSettings: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = EngineContentSettings
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.appConfiguration]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let appConfiguration = view.values[PreferencesKeys.appConfiguration]?.get(AppConfiguration.self) else {
+                    return EngineContentSettings(appConfiguration: AppConfiguration.defaultValue)
+                }
+                return EngineContentSettings(appConfiguration: appConfiguration)
+            }
+        }
+        
+        public struct LocalizationList: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = LocalizationListState
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.localizationListState]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let localizationListState = view.values[PreferencesKeys.localizationListState]?.get(LocalizationListState.self) else {
+                    return LocalizationListState.defaultSettings
+                }
+                return localizationListState
+            }
+        }
+        
+        public struct PremiumPromo: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = PremiumPromoConfiguration
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.premiumPromo]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let premiumPromoConfiguration = view.values[PreferencesKeys.premiumPromo]?.get(PremiumPromoConfiguration.self) else {
+                    return PremiumPromoConfiguration.defaultValue
+                }
+                return premiumPromoConfiguration
+            }
+        }
+        
+        public struct GlobalAutoremoveTimeout: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = Int32?
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.globalMessageAutoremoveTimeoutSettings]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let settings = view.values[PreferencesKeys.globalMessageAutoremoveTimeoutSettings]?.get(GlobalMessageAutoremoveTimeoutSettings.self) else {
+                    return GlobalMessageAutoremoveTimeoutSettings.default.messageAutoremoveTimeout
+                }
+                return settings.messageAutoremoveTimeout
+            }
+        }
+        
+        public struct Links: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = EngineConfiguration.Links
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.linksConfiguration]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let value = view.values[PreferencesKeys.linksConfiguration]?.get(LinksConfiguration.self) else {
+                    return EngineConfiguration.Links(LinksConfiguration.defaultValue)
+                }
+                return EngineConfiguration.Links(value)
+            }
+        }
+        
+        public struct GlobalPrivacy: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = GlobalPrivacySettings
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.globalPrivacySettings]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let value = view.values[PreferencesKeys.globalPrivacySettings]?.get(GlobalPrivacySettings.self) else {
+                    return GlobalPrivacySettings.default
+                }
+                return value
+            }
+        }
+        
+        public struct StoryConfigurationState: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = Stories.ConfigurationState
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.storiesConfiguration]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let value = view.values[PreferencesKeys.storiesConfiguration]?.get(Stories.ConfigurationState.self) else {
+                    return Stories.ConfigurationState.default
+                }
+                return value
+            }
+        }
+        
+        public struct AudioTranscriptionTrial: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = AudioTranscription.TrialState
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.audioTranscriptionTrialState]))
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                guard let value = view.values[PreferencesKeys.audioTranscriptionTrialState]?.get(AudioTranscription.TrialState.self) else {
+                    return AudioTranscription.TrialState.defaultValue
+                }
+                return value
+            }
+        }
+        
+        public struct AvailableColorOptions: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = EngineAvailableColorOptions
+            
+            public let scope: PeerColorsScope
+            
+            public init(scope: PeerColorsScope) {
+                self.scope = scope
+            }
+            
+            var key: PostboxViewKey {
+                let key = ValueBoxKey(length: 8)
+                switch scope {
+                case .replies:
+                    key.setInt64(0, value: 0)
+                case .profile:
+                    key.setInt64(0, value: 1)
+                }
+                let viewKey: PostboxViewKey = .cachedItem(ItemCacheEntryId(collectionId: Namespaces.CachedItemCollection.peerColorOptions, key: key))
+                return viewKey
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? CachedItemView else {
+                    preconditionFailure()
+                }
+                guard let value = view.value?.get(EngineAvailableColorOptions.self) else {
+                    return EngineAvailableColorOptions(hash: 0, options: [])
+                }
+                return value
+            }
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Data/ContactsData.swift

@@ -0,0 +1,78 @@
+import SwiftSignalKit
+import Postbox
+
+public final class EngineContactList {
+    public let peers: [EnginePeer]
+    public let presences: [EnginePeer.Id: EnginePeer.Presence]
+
+    public init(peers: [EnginePeer], presences: [EnginePeer.Id: EnginePeer.Presence]) {
+        self.peers = peers
+        self.presences = presences
+    }
+}
+
+public extension TelegramEngine.EngineData.Item {
+    enum Contacts {
+        public struct List: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = EngineContactList
+
+            private let includePresences: Bool
+
+            public init(includePresences: Bool) {
+                self.includePresences = includePresences
+            }
+
+            var key: PostboxViewKey {
+                return .contacts(accountPeerId: nil, includePresences: self.includePresences)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? ContactPeersView else {
+                    preconditionFailure()
+                }
+                return EngineContactList(peers: view.peers.map(EnginePeer.init), presences: view.peerPresences.mapValues(EnginePeer.Presence.init))
+            }
+        }
+        
+        public struct Top: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = Array<EnginePeer.Id>
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .cachedItem(cachedRecentPeersEntryId())
+            }
+            
+            func extract(view: PostboxView) -> [EnginePeer.Id] {
+                if let value = (view as? CachedItemView)?.value?.get(CachedRecentPeers.self) {
+                    if value.enabled {
+                        return value.ids
+                    } else {
+                        return []
+                    }
+                } else {
+                    return []
+                }
+            }
+        }
+        
+        public struct CloseFriends: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = Array<EnginePeer>
+
+            public init() {
+            }
+
+            var key: PostboxViewKey {
+                return .contacts(accountPeerId: nil, includePresences: false)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? ContactPeersView else {
+                    preconditionFailure()
+                }
+                return view.peers.filter { $0.isCloseFriend }.map(EnginePeer.init)
+            }
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Data/ItemCacheData.swift

@@ -0,0 +1,29 @@
+import SwiftSignalKit
+import Postbox
+
+public extension TelegramEngine.EngineData.Item {
+    enum ItemCache {
+        public struct Item: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = CodableEntry?
+
+            private let collectionId: Int8
+            private let id: ValueBoxKey
+
+            public init(collectionId: Int8, id: ValueBoxKey) {
+                self.collectionId = collectionId
+                self.id = id
+            }
+
+            var key: PostboxViewKey {
+                return .cachedItem(ItemCacheEntryId(collectionId: collectionId, key: self.id))
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? CachedItemView else {
+                    preconditionFailure()
+                }
+                return view.value
+            }
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Data/MessagesData.swift

@@ -0,0 +1,500 @@
+import SwiftSignalKit
+import Postbox
+
+public final class EngineTotalReadCounters {
+    fileprivate let state: ChatListTotalUnreadState
+
+    public init(state: ChatListTotalUnreadState) {
+        self.state = state
+    }
+
+    public func count(for category: ChatListTotalUnreadStateCategory, in statsType: ChatListTotalUnreadStateStats, with tags: PeerSummaryCounterTags) -> Int32 {
+        return self.state.count(for: category, in: statsType, with: tags)
+    }
+}
+
+public extension EngineTotalReadCounters {
+    func _asCounters() -> ChatListTotalUnreadState {
+        return self.state
+    }
+}
+
+public struct EnginePeerReadCounters: Equatable {
+    fileprivate var state: CombinedPeerReadState?
+    public var isMuted: Bool
+
+    public init(state: CombinedPeerReadState?, isMuted: Bool) {
+        self.state = state
+        self.isMuted = isMuted
+    }
+    
+    public init(state: ChatListViewReadState?) {
+        self.state = state?.state
+        self.isMuted = state?.isMuted ?? false
+    }
+
+    public init() {
+        self.state = CombinedPeerReadState(states: [])
+        self.isMuted = false
+    }
+
+    public var count: Int32 {
+        guard let state = self.state else {
+            return 0
+        }
+        return state.count
+    }
+
+    public var markedUnread: Bool {
+        guard let state = self.state else {
+            return false
+        }
+        return state.markedUnread
+    }
+
+    public var isUnread: Bool {
+        guard let state = self.state else {
+            return false
+        }
+        return state.isUnread
+    }
+    
+    public var hasEverRead: Bool {
+        guard let state = self.state else {
+            return false
+        }
+        for (_, state) in state.states {
+            switch state {
+            case let .idBased(maxIncomingReadId, _, _, _, _):
+                if maxIncomingReadId != 0 {
+                    return true
+                }
+            case .indexBased:
+                return true
+            }
+        }
+        return false
+    }
+
+    public func isOutgoingMessageIndexRead(_ index: EngineMessage.Index) -> Bool {
+        guard let state = self.state else {
+            return false
+        }
+        return state.isOutgoingMessageIndexRead(index)
+    }
+
+    public func isIncomingMessageIndexRead(_ index: EngineMessage.Index) -> Bool {
+        guard let state = self.state else {
+            return false
+        }
+        return state.isIncomingMessageIndexRead(index)
+    }
+}
+
+public extension EnginePeerReadCounters {
+    init(incomingReadId: EngineMessage.Id.Id, outgoingReadId: EngineMessage.Id.Id, count: Int32, markedUnread: Bool) {
+        self.init(state: CombinedPeerReadState(states: [(Namespaces.Message.Cloud, .idBased(maxIncomingReadId: incomingReadId, maxOutgoingReadId: outgoingReadId, maxKnownId: max(incomingReadId, outgoingReadId), count: count, markedUnread: markedUnread))]), isMuted: false)
+    }
+    
+    func _asReadCounters() -> CombinedPeerReadState? {
+        return self.state
+    }
+}
+
+public extension TelegramEngine.EngineData.Item {
+    enum Messages {
+        public struct Message: TelegramEngineDataItem, TelegramEngineMapKeyDataItem, PostboxViewDataItem {
+            public typealias Result = Optional<EngineMessage>
+
+            fileprivate var id: EngineMessage.Id
+            
+            public var mapKey: EngineMessage.Id {
+                return self.id
+            }
+
+            public init(id: EngineMessage.Id) {
+                self.id = id
+            }
+
+            var key: PostboxViewKey {
+                return .messages(Set([self.id]))
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? MessagesView else {
+                    preconditionFailure()
+                }
+                guard let message = view.messages[self.id] else {
+                    return nil
+                }
+                return EngineMessage(message)
+            }
+        }
+        
+        public struct MessageGroup: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = [EngineMessage]
+
+            fileprivate var id: EngineMessage.Id
+
+            public init(id: EngineMessage.Id) {
+                self.id = id
+            }
+
+            var key: PostboxViewKey {
+                return .messageGroup(id: self.id)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? MessageGroupView else {
+                    preconditionFailure()
+                }
+                return view.messages.map(EngineMessage.init)
+            }
+        }
+
+        public struct Messages: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = [EngineMessage.Id: EngineMessage]
+
+            fileprivate var ids: Set<EngineMessage.Id>
+
+            public init(ids: Set<EngineMessage.Id>) {
+                self.ids = ids
+            }
+
+            var key: PostboxViewKey {
+                return .messages(self.ids)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? MessagesView else {
+                    preconditionFailure()
+                }
+                var result: [EngineMessage.Id: EngineMessage] = [:]
+                for (id, message) in view.messages {
+                    result[id] = EngineMessage(message)
+                }
+                return result
+            }
+        }
+        
+        public struct PeerReadCounters: TelegramEngineDataItem, TelegramEngineMapKeyDataItem, PostboxViewDataItem {
+            public typealias Result = EnginePeerReadCounters
+
+            fileprivate let id: EnginePeer.Id
+            public var mapKey: EnginePeer.Id {
+                return self.id
+            }
+
+            var key: PostboxViewKey {
+                return .combinedReadState(peerId: self.id, handleThreads: true)
+            }
+
+            public init(id: EnginePeer.Id) {
+                self.id = id
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? CombinedReadStateView else {
+                    preconditionFailure()
+                }
+
+                return EnginePeerReadCounters(state: view.state, isMuted: false)
+            }
+        }
+
+        public struct PeerUnreadCount: TelegramEngineDataItem, TelegramEngineMapKeyDataItem, PostboxViewDataItem {
+            public typealias Result = Int
+
+            fileprivate let id: EnginePeer.Id
+            public var mapKey: EnginePeer.Id {
+                return self.id
+            }
+
+            var key: PostboxViewKey {
+                return .unreadCounts(items: [.peer(id: self.id, handleThreads: true)])
+            }
+
+            public init(id: EnginePeer.Id) {
+                self.id = id
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? UnreadMessageCountsView else {
+                    preconditionFailure()
+                }
+
+                return Int(view.count(for: .peer(id: self.id, handleThreads: true)) ?? 0)
+            }
+        }
+        
+        public struct PeerUnreadState: TelegramEngineDataItem, TelegramEngineMapKeyDataItem, PostboxViewDataItem {
+            public struct Result: Equatable {
+                public var count: Int
+                public var isMarkedUnread: Bool
+                
+                public init(count: Int, isMarkedUnread: Bool) {
+                    self.count = count
+                    self.isMarkedUnread = isMarkedUnread
+                }
+            }
+
+            fileprivate let id: EnginePeer.Id
+            public var mapKey: EnginePeer.Id {
+                return self.id
+            }
+
+            var key: PostboxViewKey {
+                return .unreadCounts(items: [.peer(id: self.id, handleThreads: true)])
+            }
+
+            public init(id: EnginePeer.Id) {
+                self.id = id
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? UnreadMessageCountsView else {
+                    preconditionFailure()
+                }
+
+                if let (value, isUnread) = view.countOrUnread(for: .peer(id: self.id, handleThreads: true)) {
+                    return Result(count: Int(value), isMarkedUnread: isUnread)
+                }
+                return Result(count: 0, isMarkedUnread: false)
+            }
+        }
+
+        public struct TotalReadCounters: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = EngineTotalReadCounters
+
+            public init() {
+            }
+
+            var key: PostboxViewKey {
+                return .unreadCounts(items: [.total(nil)])
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? UnreadMessageCountsView else {
+                    preconditionFailure()
+                }
+                guard let (_, total) = view.total() else {
+                    return EngineTotalReadCounters(state: ChatListTotalUnreadState(absoluteCounters: [:], filteredCounters: [:]))
+                }
+                return EngineTotalReadCounters(state: total)
+            }
+        }
+        
+        public struct ChatListIndex: TelegramEngineDataItem, TelegramEngineMapKeyDataItem, PostboxViewDataItem {
+            public typealias Result = EngineChatList.Item.Index?
+            
+            fileprivate var id: EnginePeer.Id
+            public var mapKey: EnginePeer.Id {
+                return self.id
+            }
+            
+            public init(id: EnginePeer.Id) {
+                self.id = id
+            }
+
+            var key: PostboxViewKey {
+                return .chatListIndex(id: self.id)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? ChatListIndexView else {
+                    preconditionFailure()
+                }
+                return view.chatListIndex.flatMap(EngineChatList.Item.Index.chatList)
+            }
+        }
+        
+        public struct ChatListGroup: TelegramEngineDataItem, TelegramEngineMapKeyDataItem, PostboxViewDataItem {
+            public typealias Result = EngineChatList.Group?
+            
+            fileprivate var id: EnginePeer.Id
+            public var mapKey: EnginePeer.Id {
+                return self.id
+            }
+            
+            public init(id: EnginePeer.Id) {
+                self.id = id
+            }
+
+            var key: PostboxViewKey {
+                return .chatListIndex(id: self.id)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? ChatListIndexView else {
+                    preconditionFailure()
+                }
+                return view.inclusion.groupId.flatMap(EngineChatList.Group.init)
+            }
+        }
+        
+        public struct MessageCount: TelegramEngineDataItem, TelegramEngineMapKeyDataItem, PostboxViewDataItem {
+            public struct ItemKey: Hashable {
+                public var peerId: EnginePeer.Id
+                public var tag: MessageTags
+                public var threadId: Int64?
+            }
+            
+            public typealias Result = Int?
+            
+            fileprivate var peerId: EnginePeer.Id
+            fileprivate var tag: MessageTags
+            fileprivate var threadId: Int64?
+            public var mapKey: ItemKey {
+                return ItemKey(peerId: self.peerId, tag: self.tag, threadId: self.threadId)
+            }
+            
+            public init(peerId: EnginePeer.Id, threadId: Int64?, tag: MessageTags) {
+                self.peerId = peerId
+                self.threadId = threadId
+                self.tag = tag
+            }
+
+            var key: PostboxViewKey {
+                return .historyTagSummaryView(tag: self.tag, peerId: self.peerId, threadId: self.threadId, namespace: Namespaces.Message.Cloud, customTag: nil)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? MessageHistoryTagSummaryView else {
+                    preconditionFailure()
+                }
+                return view.count.flatMap(Int.init)
+            }
+        }
+        
+        public struct ReactionTagMessageCount: TelegramEngineDataItem, TelegramEngineMapKeyDataItem, PostboxViewDataItem {
+            public struct ItemKey: Hashable {
+                public var peerId: EnginePeer.Id
+                public var threadId: Int64?
+                public var reaction: MessageReaction.Reaction
+            }
+            
+            public typealias Result = Int?
+            
+            fileprivate var peerId: EnginePeer.Id
+            fileprivate var threadId: Int64?
+            fileprivate var reaction: MessageReaction.Reaction
+            public var mapKey: ItemKey {
+                return ItemKey(peerId: self.peerId, threadId: self.threadId, reaction: self.reaction)
+            }
+            
+            public init(peerId: EnginePeer.Id, threadId: Int64?, reaction: MessageReaction.Reaction) {
+                self.peerId = peerId
+                self.threadId = threadId
+                self.reaction = reaction
+            }
+
+            var key: PostboxViewKey {
+                return .historyTagSummaryView(tag: [], peerId: self.peerId, threadId: self.threadId, namespace: Namespaces.Message.Cloud, customTag: ReactionsMessageAttribute.messageTag(reaction: self.reaction))
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? MessageHistoryTagSummaryView else {
+                    preconditionFailure()
+                }
+                return view.count.flatMap(Int.init)
+            }
+        }
+        
+        public struct TopMessage: TelegramEngineDataItem, TelegramEngineMapKeyDataItem, PostboxViewDataItem {
+            public typealias Result = EngineMessage?
+            
+            fileprivate var id: EnginePeer.Id
+            public var mapKey: EnginePeer.Id {
+                return self.id
+            }
+            
+            public init(id: EnginePeer.Id) {
+                self.id = id
+            }
+
+            var key: PostboxViewKey {
+                return .topChatMessage(peerIds: [self.id])
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? TopChatMessageView else {
+                    preconditionFailure()
+                }
+                guard let message = view.messages[self.id] else {
+                    return nil
+                }
+                return EngineMessage(message)
+            }
+        }
+        
+        public struct SavedMessageTagStats: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = [MessageReaction.Reaction: Int]
+            
+            fileprivate var peerId: EnginePeer.Id
+            fileprivate var threadId: Int64?
+            
+            public init(peerId: EnginePeer.Id, threadId: Int64?) {
+                self.peerId = peerId
+                self.threadId = threadId
+            }
+
+            var key: PostboxViewKey {
+                return .historyCustomTagSummariesView(peerId: self.peerId, threadId: self.threadId, namespace: Namespaces.Message.Cloud)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? MessageHistoryCustomTagSummariesView else {
+                    preconditionFailure()
+                }
+                var result: [MessageReaction.Reaction: Int] = [:]
+                for (key, value) in view.tags {
+                    if let reaction = ReactionsMessageAttribute.reactionFromMessageTag(tag: key) {
+                        result[reaction] = value
+                    }
+                }
+                return result
+            }
+        }
+        
+        public struct ThreadInfo: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = MessageHistoryThreadData?
+            
+            fileprivate var peerId: EnginePeer.Id
+            fileprivate var threadId: Int64
+            
+            public init(peerId: EnginePeer.Id, threadId: Int64) {
+                self.peerId = peerId
+                self.threadId = threadId
+            }
+
+            var key: PostboxViewKey {
+                return .messageHistoryThreadInfo(peerId: self.peerId, threadId: self.threadId)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? MessageHistoryThreadInfoView else {
+                    preconditionFailure()
+                }
+                return view.info?.data.get(MessageHistoryThreadData.self)
+            }
+        }
+        
+        public struct GlobalPostSearchState: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = TelegramGlobalPostSearchState?
+            
+            public init() {
+            }
+
+            var key: PostboxViewKey {
+                return .preferences(keys: Set([PreferencesKeys.globalPostSearchState()]))
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? PreferencesView else {
+                    preconditionFailure()
+                }
+                return view.values[PreferencesKeys.globalPostSearchState()]?.get(TelegramGlobalPostSearchState.self)
+            }
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Data/NoticesData.swift

@@ -0,0 +1,27 @@
+import SwiftSignalKit
+import Postbox
+
+public extension TelegramEngine.EngineData.Item {
+    enum Notices {
+        public struct Notice: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = CodableEntry?
+            
+            private let entryKey: NoticeEntryKey
+
+            public init(key: NoticeEntryKey) {
+                self.entryKey = key
+            }
+
+            var key: PostboxViewKey {
+                return .notice(key: self.entryKey)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? LocalNoticeEntryView else {
+                    preconditionFailure()
+                }
+                return view.value
+            }
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Data/OrderedListsData.swift

@@ -0,0 +1,69 @@
+import SwiftSignalKit
+import Postbox
+
+public extension TelegramEngine.EngineData.Item {
+    enum Collections {
+        public struct FeaturedStickerPacks: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = [FeaturedStickerPackItem]
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .orderedItemList(id: Namespaces.OrderedItemList.CloudFeaturedStickerPacks)
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? OrderedItemListView else {
+                    preconditionFailure()
+                }
+                return view.items.compactMap { item in
+                    return item.contents.get(FeaturedStickerPackItem.self)
+                }
+            }
+        }
+        
+        public struct FeaturedEmojiPacks: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = [FeaturedStickerPackItem]
+            
+            public init() {
+            }
+            
+            var key: PostboxViewKey {
+                return .orderedItemList(id: Namespaces.OrderedItemList.CloudFeaturedEmojiPacks)
+            }
+            
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? OrderedItemListView else {
+                    preconditionFailure()
+                }
+                return view.items.compactMap { item in
+                    return item.contents.get(FeaturedStickerPackItem.self)
+                }
+            }
+        }
+    }
+    
+    enum OrderedLists {
+        public struct ListItems: TelegramEngineDataItem, PostboxViewDataItem {
+            public typealias Result = [OrderedItemListEntry]
+
+            private let collectionId: Int32
+
+            public init(collectionId: Int32) {
+                self.collectionId = collectionId
+            }
+
+            var key: PostboxViewKey {
+                return .orderedItemList(id: self.collectionId)
+            }
+
+            func extract(view: PostboxView) -> Result {
+                guard let view = view as? OrderedItemListView else {
+                    preconditionFailure()
+                }
+                return view.items
+            }
+        }
+    }
+}

submodules/TelegramCore/Sources/TelegramEngine/Data/TelegramEngineData.swift

@@ -0,0 +1,748 @@
+import SwiftSignalKit
+import Postbox
+
+public protocol TelegramEngineDataItem {
+    associatedtype Result
+}
+
+public protocol TelegramEngineMapKeyDataItem {
+    associatedtype Key: Hashable
+
+    var mapKey: Key { get }
+}
+
+protocol AnyPostboxViewDataItem {
+    func keys(data: TelegramEngine.EngineData) -> [PostboxViewKey]
+
+    func _extract(data: TelegramEngine.EngineData, views: [PostboxViewKey: PostboxView]) -> Any
+}
+
+protocol PostboxViewDataItem: TelegramEngineDataItem, AnyPostboxViewDataItem {
+    var key: PostboxViewKey { get }
+
+    func extract(view: PostboxView) -> Result
+}
+
+extension PostboxViewDataItem {
+    func keys(data: TelegramEngine.EngineData) -> [PostboxViewKey] {
+        return [self.key]
+    }
+
+    func _extract(data: TelegramEngine.EngineData, views: [PostboxViewKey: PostboxView]) -> Any {
+        return self.extract(view: views[self.key]!)
+    }
+}
+
+public final class EngineDataMap<Item: TelegramEngineDataItem & TelegramEngineMapKeyDataItem>: TelegramEngineDataItem, AnyPostboxViewDataItem {
+    public typealias Result = [Item.Key: Item.Result]
+
+    private let items: [Item]
+
+    public init(_ items: [Item]) {
+        self.items = items
+    }
+
+    func keys(data: TelegramEngine.EngineData) -> [PostboxViewKey] {
+        var keys = Set<PostboxViewKey>()
+        for item in self.items {
+            for key in (item as! AnyPostboxViewDataItem).keys(data: data) {
+                keys.insert(key)
+            }
+        }
+        return Array(keys)
+    }
+
+    func _extract(data: TelegramEngine.EngineData, views: [PostboxViewKey: PostboxView]) -> Any {
+        var result: [Item.Key: Item.Result] = [:]
+
+        for item in self.items {
+            let itemResult = (item as! AnyPostboxViewDataItem)._extract(data: data, views: views)
+            result[item.mapKey] = (itemResult as! Item.Result)
+        }
+
+        return result
+    }
+}
+
+public final class EngineDataList<Item: TelegramEngineDataItem & TelegramEngineMapKeyDataItem>: TelegramEngineDataItem, AnyPostboxViewDataItem {
+    public typealias Result = [Item.Result]
+
+    private let items: [Item]
+
+    public init(_ items: [Item]) {
+        self.items = items
+    }
+
+    func keys(data: TelegramEngine.EngineData) -> [PostboxViewKey] {
+        var keys = Set<PostboxViewKey>()
+        for item in self.items {
+            for key in (item as! AnyPostboxViewDataItem).keys(data: data) {
+                keys.insert(key)
+            }
+        }
+        return Array(keys)
+    }
+
+    func _extract(data: TelegramEngine.EngineData, views: [PostboxViewKey: PostboxView]) -> Any {
+        var result: [Item.Result] = []
+
+        for item in self.items {
+            let itemResult = (item as! AnyPostboxViewDataItem)._extract(data: data, views: views)
+            result.append(itemResult as! Item.Result)
+        }
+
+        return result
+    }
+}
+
+public final class EngineDataOptional<Item: TelegramEngineDataItem>: TelegramEngineDataItem, AnyPostboxViewDataItem {
+    public typealias Result = Item.Result?
+
+    private let item: Item?
+
+    public init(_ item: Item?) {
+        self.item = item
+    }
+
+    func keys(data: TelegramEngine.EngineData) -> [PostboxViewKey] {
+        var keys = Set<PostboxViewKey>()
+        if let item = self.item {
+            for key in (item as! AnyPostboxViewDataItem).keys(data: data) {
+                keys.insert(key)
+            }
+        }
+        return Array(keys)
+    }
+
+    func _extract(data: TelegramEngine.EngineData, views: [PostboxViewKey: PostboxView]) -> Any {
+        var result: Item.Result?
+
+        if let item = self.item {
+            let itemResult = (item as! AnyPostboxViewDataItem)._extract(data: data, views: views)
+            result = (itemResult as! Item.Result)
+        }
+
+        return result as Any
+    }
+}
+
+public extension TelegramEngine {
+    final class EngineData {
+        public struct Item {
+        }
+
+        let accountPeerId: PeerId
+        private let postbox: Postbox
+
+        public init(accountPeerId: PeerId, postbox: Postbox) {
+            self.accountPeerId = accountPeerId
+            self.postbox = postbox
+        }
+
+        private func _subscribe(items: [AnyPostboxViewDataItem]) -> Signal<[Any], NoError> {
+            var keys = Set<PostboxViewKey>()
+            for item in items {
+                for key in item.keys(data: self) {
+                    keys.insert(key)
+                }
+            }
+            return self.postbox.combinedView(keys: Array(keys))
+            |> map { views -> [Any] in
+                var results: [Any] = []
+
+                for item in items {
+                    results.append(item._extract(data: self, views: views.views))
+                }
+
+                return results
+            }
+        }
+        
+        /*public func subscribe<each T: TelegramEngineDataItem>(_ ts: repeat each T) -> Signal<repeat each T, NoError> {
+        }*/
+
+        public func subscribe<T0: TelegramEngineDataItem>(_ t0: T0) -> Signal<T0.Result, NoError> {
+            return self._subscribe(items: [t0 as! AnyPostboxViewDataItem])
+            |> map { results -> T0.Result in
+                return results[0] as! T0.Result
+            }
+        }
+        public func get<T0: TelegramEngineDataItem>(_ t0: T0) -> Signal<T0.Result, NoError> {
+            return self.subscribe(t0)
+            |> take(1)
+        }
+
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result
+                )
+            }
+        }
+        
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem,
+                t2 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result, T2.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result,
+                    results[2] as! T2.Result
+                )
+            }
+        }
+        
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem,
+                t2 as! AnyPostboxViewDataItem,
+                t3 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result, T2.Result, T3.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result,
+                    results[2] as! T2.Result,
+                    results[3] as! T3.Result
+                )
+            }
+        }
+        
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem,
+            T4: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3,
+            _ t4: T4
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result,
+                T4.Result
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem,
+                t2 as! AnyPostboxViewDataItem,
+                t3 as! AnyPostboxViewDataItem,
+                t4 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result, T2.Result, T3.Result, T4.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result,
+                    results[2] as! T2.Result,
+                    results[3] as! T3.Result,
+                    results[4] as! T4.Result
+                )
+            }
+        }
+        
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem,
+            T4: TelegramEngineDataItem,
+            T5: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3,
+            _ t4: T4,
+            _ t5: T5
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result,
+                T4.Result,
+                T5.Result
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem,
+                t2 as! AnyPostboxViewDataItem,
+                t3 as! AnyPostboxViewDataItem,
+                t4 as! AnyPostboxViewDataItem,
+                t5 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result, T2.Result, T3.Result, T4.Result, T5.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result,
+                    results[2] as! T2.Result,
+                    results[3] as! T3.Result,
+                    results[4] as! T4.Result,
+                    results[5] as! T5.Result
+                )
+            }
+        }
+        
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem,
+            T4: TelegramEngineDataItem,
+            T5: TelegramEngineDataItem,
+            T6: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3,
+            _ t4: T4,
+            _ t5: T5,
+            _ t6: T6
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result,
+                T4.Result,
+                T5.Result,
+                T6.Result
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem,
+                t2 as! AnyPostboxViewDataItem,
+                t3 as! AnyPostboxViewDataItem,
+                t4 as! AnyPostboxViewDataItem,
+                t5 as! AnyPostboxViewDataItem,
+                t6 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result, T2.Result, T3.Result, T4.Result, T5.Result, T6.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result,
+                    results[2] as! T2.Result,
+                    results[3] as! T3.Result,
+                    results[4] as! T4.Result,
+                    results[5] as! T5.Result,
+                    results[6] as! T6.Result
+                )
+            }
+        }
+        
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem,
+            T4: TelegramEngineDataItem,
+            T5: TelegramEngineDataItem,
+            T6: TelegramEngineDataItem,
+            T7: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3,
+            _ t4: T4,
+            _ t5: T5,
+            _ t6: T6,
+            _ t7: T7
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result,
+                T4.Result,
+                T5.Result,
+                T6.Result,
+                T7.Result
+
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem,
+                t2 as! AnyPostboxViewDataItem,
+                t3 as! AnyPostboxViewDataItem,
+                t4 as! AnyPostboxViewDataItem,
+                t5 as! AnyPostboxViewDataItem,
+                t6 as! AnyPostboxViewDataItem,
+                t7 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result, T2.Result, T3.Result, T4.Result, T5.Result, T6.Result, T7.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result,
+                    results[2] as! T2.Result,
+                    results[3] as! T3.Result,
+                    results[4] as! T4.Result,
+                    results[5] as! T5.Result,
+                    results[6] as! T6.Result,
+                    results[7] as! T7.Result
+                )
+            }
+        }
+        
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem,
+            T4: TelegramEngineDataItem,
+            T5: TelegramEngineDataItem,
+            T6: TelegramEngineDataItem,
+            T7: TelegramEngineDataItem,
+            T8: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3,
+            _ t4: T4,
+            _ t5: T5,
+            _ t6: T6,
+            _ t7: T7,
+            _ t8: T8
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result,
+                T4.Result,
+                T5.Result,
+                T6.Result,
+                T7.Result,
+                T8.Result
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem,
+                t2 as! AnyPostboxViewDataItem,
+                t3 as! AnyPostboxViewDataItem,
+                t4 as! AnyPostboxViewDataItem,
+                t5 as! AnyPostboxViewDataItem,
+                t6 as! AnyPostboxViewDataItem,
+                t7 as! AnyPostboxViewDataItem,
+                t8 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result, T2.Result, T3.Result, T4.Result, T5.Result, T6.Result, T7.Result, T8.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result,
+                    results[2] as! T2.Result,
+                    results[3] as! T3.Result,
+                    results[4] as! T4.Result,
+                    results[5] as! T5.Result,
+                    results[6] as! T6.Result,
+                    results[7] as! T7.Result,
+                    results[8] as! T8.Result
+                )
+            }
+        }
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem,
+            T4: TelegramEngineDataItem,
+            T5: TelegramEngineDataItem,
+            T6: TelegramEngineDataItem,
+            T7: TelegramEngineDataItem,
+            T8: TelegramEngineDataItem,
+            T9: TelegramEngineDataItem
+
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3,
+            _ t4: T4,
+            _ t5: T5,
+            _ t6: T6,
+            _ t7: T7,
+            _ t8: T8,
+            _ t9: T9
+
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result,
+                T4.Result,
+                T5.Result,
+                T6.Result,
+                T7.Result,
+                T8.Result,
+                T9.Result
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem,
+                t2 as! AnyPostboxViewDataItem,
+                t3 as! AnyPostboxViewDataItem,
+                t4 as! AnyPostboxViewDataItem,
+                t5 as! AnyPostboxViewDataItem,
+                t6 as! AnyPostboxViewDataItem,
+                t7 as! AnyPostboxViewDataItem,
+                t8 as! AnyPostboxViewDataItem,
+                t9 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result, T2.Result, T3.Result, T4.Result, T5.Result, T6.Result, T7.Result, T8.Result, T9.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result,
+                    results[2] as! T2.Result,
+                    results[3] as! T3.Result,
+                    results[4] as! T4.Result,
+                    results[5] as! T5.Result,
+                    results[6] as! T6.Result,
+                    results[7] as! T7.Result,
+                    results[8] as! T8.Result,
+                    results[9] as! T9.Result
+                )
+            }
+        }
+        
+        public func subscribe<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem,
+            T4: TelegramEngineDataItem,
+            T5: TelegramEngineDataItem,
+            T6: TelegramEngineDataItem,
+            T7: TelegramEngineDataItem,
+            T8: TelegramEngineDataItem,
+            T9: TelegramEngineDataItem,
+            T10: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3,
+            _ t4: T4,
+            _ t5: T5,
+            _ t6: T6,
+            _ t7: T7,
+            _ t8: T8,
+            _ t9: T9,
+            _ t10: T10
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result,
+                T4.Result,
+                T5.Result,
+                T6.Result,
+                T7.Result,
+                T8.Result,
+                T9.Result,
+                T10.Result
+            ),
+        NoError> {
+            return self._subscribe(items: [
+                t0 as! AnyPostboxViewDataItem,
+                t1 as! AnyPostboxViewDataItem,
+                t2 as! AnyPostboxViewDataItem,
+                t3 as! AnyPostboxViewDataItem,
+                t4 as! AnyPostboxViewDataItem,
+                t5 as! AnyPostboxViewDataItem,
+                t6 as! AnyPostboxViewDataItem,
+                t7 as! AnyPostboxViewDataItem,
+                t8 as! AnyPostboxViewDataItem,
+                t9 as! AnyPostboxViewDataItem,
+                t10 as! AnyPostboxViewDataItem
+            ])
+            |> map { results -> (T0.Result, T1.Result, T2.Result, T3.Result, T4.Result, T5.Result, T6.Result, T7.Result, T8.Result, T9.Result, T10.Result) in
+                return (
+                    results[0] as! T0.Result,
+                    results[1] as! T1.Result,
+                    results[2] as! T2.Result,
+                    results[3] as! T3.Result,
+                    results[4] as! T4.Result,
+                    results[5] as! T5.Result,
+                    results[6] as! T6.Result,
+                    results[7] as! T7.Result,
+                    results[8] as! T8.Result,
+                    results[9] as! T9.Result,
+                    results[10] as! T10.Result
+                )
+            }
+        }
+
+        
+        public func get<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result
+            ),
+        NoError> {
+            return self.subscribe(t0, t1) |> take(1)
+        }
+        
+        public func get<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result
+            ),
+        NoError> {
+            return self.subscribe(t0, t1, t2) |> take(1)
+        }
+        
+        public func get<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result
+            ),
+        NoError> {
+            return self.subscribe(t0, t1, t2, t3) |> take(1)
+        }
+        
+        public func get<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem,
+            T4: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3,
+            _ t4: T4
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result,
+                T4.Result
+            ),
+        NoError> {
+            return self.subscribe(t0, t1, t2, t3, t4) |> take(1)
+        }
+        
+        public func get<
+            T0: TelegramEngineDataItem,
+            T1: TelegramEngineDataItem,
+            T2: TelegramEngineDataItem,
+            T3: TelegramEngineDataItem,
+            T4: TelegramEngineDataItem,
+            T5: TelegramEngineDataItem
+        >(
+            _ t0: T0,
+            _ t1: T1,
+            _ t2: T2,
+            _ t3: T3,
+            _ t4: T4,
+            _ t5: T5
+        ) -> Signal<
+            (
+                T0.Result,
+                T1.Result,
+                T2.Result,
+                T3.Result,
+                T4.Result,
+                T5.Result
+            ),
+        NoError> {
+            return self.subscribe(t0, t1, t2, t3, t4, t5) |> take(1)
+        }
+    }
+}