add a lot of things from update

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/Common.kt

@@ -291,6 +291,7 @@ const val canSendPaidMediaField = "can_send_paid_media"
 const val activeUsernamesField = "active_usernames"
 const val customTitleField = "custom_title"
 const val optionIdsField = "option_ids"
+const val parentChatField = "parent_chat"
 const val voterChatField = "voter_chat"
 const val ipAddressField = "ip_address"
 const val linkedChatIdField = "linked_chat_id"
@@ -535,6 +536,7 @@ const val convertStarCountField = "convert_star_count"
 const val prepaidUpgradeStarCountField = "prepaid_upgrade_star_count"
 const val canBeUpgradedField = "can_be_upgraded"
 const val isPrivateField = "is_private"
+const val isDirectMessagesField = "is_direct_messages"
 const val nextTransferDateField = "next_transfer_date"
 const val transferStarCountField = "transfer_star_count"
 const val lastResaleStarCountField = "last_resale_star_count"

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/chat/Abstracts.kt

@@ -53,6 +53,13 @@ sealed interface SupergroupChat : GroupChat, SuperPublicChat
 @Serializable(ChatSerializer::class)
 sealed interface ForumChat : SupergroupChat
 
+@Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+@Serializable(ChatSerializer::class)
+sealed interface ChannelDirectMessagesChat : ForumChat {
+    override val isDirectMessages: Boolean
+        get() = true
+}
+
 @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
 @Serializable(ChatSerializer::class)
 sealed interface PossiblyPremiumChat : Chat {
@@ -69,4 +76,6 @@ sealed interface AbleToAddInAttachmentMenuChat : Chat {
 @ClassCastsIncluded(excludeRegex = ".*Impl")
 sealed interface Chat {
     val id: IdChatIdentifier
+    val isDirectMessages: Boolean
+        get() = false
 }

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/chat/ChatSerializers.kt

@@ -123,16 +123,20 @@ object PreviewChatSerializer : KSerializer<PreviewChat> {
 
         val type = decodedJson[typeField] ?.jsonPrimitive ?.content ?.asChatType
         val isForum = decodedJson[isForumField] ?.jsonPrimitive ?.booleanOrNull == true
+        val isChannelDirectMessages = decodedJson[isDirectMessagesField] ?.jsonPrimitive ?.booleanOrNull == true
         val original = decodedJson[originField]
 
         return when (type) {
             ChatType.Sender -> formatter.decodeFromJsonElement(PrivateChatImpl.serializer(), decodedJson)
             ChatType.Private -> formatter.decodeFromJsonElement(PrivateChatImpl.serializer(), decodedJson)
             ChatType.Group -> formatter.decodeFromJsonElement(GroupChatImpl.serializer(), decodedJson)
-            ChatType.Supergroup -> if (isForum) {
-                formatter.decodeFromJsonElement(ForumChatImpl.serializer(), decodedJson)
-            } else {
-                formatter.decodeFromJsonElement(SupergroupChatImpl.serializer(), decodedJson)
+            ChatType.Supergroup -> {
+                @Suppress("SimplifyBooleanWithConstants")
+                when {
+                    isForum == false -> formatter.decodeFromJsonElement(SupergroupChatImpl.serializer(), decodedJson)
+                    isChannelDirectMessages -> formatter.decodeFromJsonElement(ChannelDirectMessagesChatImpl.serializer(), decodedJson)
+                    else -> formatter.decodeFromJsonElement(ForumChatImpl.serializer(), decodedJson)
+                }
             }
             ChatType.Channel -> formatter.decodeFromJsonElement(ChannelChatImpl.serializer(), decodedJson)
             is ChatType.Unknown -> UnknownChatType(
@@ -156,6 +160,7 @@ object PreviewChatSerializer : KSerializer<PreviewChat> {
             is GroupChatImpl -> GroupChatImpl.serializer().serialize(encoder, value)
             is SupergroupChatImpl -> SupergroupChatImpl.serializer().serialize(encoder, value)
             is ForumChatImpl -> ForumChatImpl.serializer().serialize(encoder, value)
+            is ChannelDirectMessagesChatImpl -> ChannelDirectMessagesChatImpl.serializer().serialize(encoder, value)
             is ChannelChatImpl -> ChannelChatImpl.serializer().serialize(encoder, value)
             is CommonBot -> CommonBot.serializer().serialize(encoder, value)
             is CommonUser -> CommonUser.serializer().serialize(encoder, value)
@@ -174,16 +179,20 @@ sealed class ExtendedChatSerializer : KSerializer<ExtendedChat> {
 
         val type = decodedJson[typeField] ?.jsonPrimitive ?.content ?.asChatType
         val isForum = decodedJson[isForumField] ?.jsonPrimitive ?.booleanOrNull == true
+        val isChannelDirectMessages = decodedJson[isDirectMessagesField] ?.jsonPrimitive ?.booleanOrNull == true
         val original = decodedJson[originField]
 
         return when (type) {
             ChatType.Sender -> formatter.decodeFromJsonElement(ExtendedPrivateChatImpl.serializer(), decodedJson)
             ChatType.Private -> formatter.decodeFromJsonElement(ExtendedPrivateChatImpl.serializer(), decodedJson)
             ChatType.Group -> formatter.decodeFromJsonElement(ExtendedGroupChatImpl.serializer(), decodedJson)
-            ChatType.Supergroup -> if (isForum) {
-                formatter.decodeFromJsonElement(ExtendedForumChatImpl.serializer(), decodedJson)
-            } else {
-                formatter.decodeFromJsonElement(ExtendedSupergroupChatImpl.serializer(), decodedJson)
+            ChatType.Supergroup -> {
+                @Suppress("SimplifyBooleanWithConstants")
+                when {
+                    isForum == false -> formatter.decodeFromJsonElement(ExtendedSupergroupChatImpl.serializer(), decodedJson)
+                    isChannelDirectMessages -> formatter.decodeFromJsonElement(ExtendedChannelDirectMessagesChatImpl.serializer(), decodedJson)
+                    else -> formatter.decodeFromJsonElement(ExtendedForumChatImpl.serializer(), decodedJson)
+                }
             }
             ChatType.Channel -> formatter.decodeFromJsonElement(ExtendedChannelChatImpl.serializer(), decodedJson)
             is ChatType.Unknown -> UnknownExtendedChat(
@@ -207,6 +216,7 @@ sealed class ExtendedChatSerializer : KSerializer<ExtendedChat> {
             is ExtendedGroupChatImpl -> ExtendedGroupChatImpl.serializer().serialize(encoder, value)
             is ExtendedSupergroupChatImpl -> ExtendedSupergroupChatImpl.serializer().serialize(encoder, value)
             is ExtendedForumChatImpl -> ExtendedForumChatImpl.serializer().serialize(encoder, value)
+            is ExtendedChannelDirectMessagesChatImpl -> ExtendedChannelDirectMessagesChatImpl.serializer().serialize(encoder, value)
             is ExtendedChannelChatImpl -> ExtendedChannelChatImpl.serializer().serialize(encoder, value)
             is ExtendedBot -> ExtendedBot.serializer().serialize(encoder, value)
             is UnknownExtendedChat -> JsonObject.serializer().serialize(encoder, value.rawJson)

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/chat/Extended.kt

@@ -10,6 +10,7 @@ import dev.inmo.tgbotapi.types.message.abstracts.Message
 import dev.inmo.tgbotapi.types.message.abstracts.TelegramBotAPIMessageDeserializeOnlySerializer
 import dev.inmo.tgbotapi.types.reactions.Reaction
 import dev.inmo.tgbotapi.utils.RiskFeature
+import kotlinx.serialization.EncodeDefault
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.JsonObject
@@ -305,6 +306,83 @@ data class ExtendedForumChatImpl(
     override val acceptedGiftTypes: AcceptedGiftTypes = AcceptedGiftTypes(),
 ) : ExtendedForumChat
 
+@Serializable
+@RiskFeature("This class is a subject of changes. It is better to use ExtendedForumChat due")
+data class ExtendedChannelDirectMessagesChatImpl(
+    @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+    @SerialName(idField)
+    override val id: IdChatIdentifier,
+    @SerialName(titleField)
+    override val title: String,
+    @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+    @SerialName(parentChatField)
+    override val channelChat: PreviewChannelChat,
+    @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+    @SerialName(usernameField)
+    override val username: Username? = null,
+    @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+    @SerialName(activeUsernamesField)
+    override val activeUsernames: List<Username> = emptyList(),
+    @SerialName(photoField)
+    override val chatPhoto: ChatPhoto? = null,
+    @SerialName(permissionsField)
+    override val permissions: ChatPermissions,
+    @SerialName(descriptionField)
+    override val description: String = "",
+    @SerialName(inviteLinkField)
+    override val inviteLink: String? = null,
+    @SerialName(pinnedMessageField)
+    @Serializable(TelegramBotAPIMessageDeserializeOnlySerializer::class)
+    override val pinnedMessage: Message? = null,
+    @SerialName(stickerSetNameFullField)
+    override val stickerSetName: StickerSetName? = null,
+    @SerialName(slowModeDelayField)
+    override val slowModeDelay: Long? = null,
+    @SerialName(canSetStickerSetField)
+    override val canSetStickerSet: Boolean = false,
+    @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+    @SerialName(linkedChatIdField)
+    override val linkedChannelChatId: IdChatIdentifier? = null,
+    @SerialName(locationField)
+    override val location: ChatLocation? = null,
+    @SerialName(joinToSendMessagesField)
+    override val requiresJoinForMessaging: Boolean = false,
+    @SerialName(joinByRequestField)
+    override val requireAdminApproveToJoin: Boolean = false,
+    @SerialName(hasAggressiveAntiSpamEnabledField)
+    override val isAggressiveAntiSpamEnabled: Boolean = false,
+    @SerialName(hasHiddenMembersField)
+    override val membersHidden: Boolean = false,
+    @SerialName(availableReactionsField)
+    override val availableReactions: List<Reaction>? = null,
+    @SerialName(emojiStatusCustomEmojiIdField)
+    override val statusEmojiId: CustomEmojiId? = null,
+    @SerialName(emojiStatusExpirationDateField)
+    override val statusEmojiExpiration: TelegramDate? = null,
+    @SerialName(accentColorIdField)
+    override val accentColorId: ColorId = ColorId(0),
+    @SerialName(profileAccentColorIdField)
+    override val profileAccentColorId: ColorId? = null,
+    @SerialName(backgroundCustomEmojiIdField)
+    override val backgroundCustomEmojiId: CustomEmojiId? = null,
+    @SerialName(profileBackgroundCustomEmojiIdField)
+    override val profileBackgroundCustomEmojiId: CustomEmojiId? = null,
+    @SerialName(hasVisibleHistoryField)
+    override val newMembersSeeHistory: Boolean = false,
+    @SerialName(unrestrictBoostsCountField)
+    override val unrestrictBoostsCount: Int? = null,
+    @SerialName(customEmojiStickerSetNameField)
+    override val customEmojiStickerSetName: StickerSetName? = null,
+    @SerialName(maxReactionCountField)
+    override val maxReactionsCount: Int = 3,
+    @SerialName(acceptedGiftTypesField)
+    override val acceptedGiftTypes: AcceptedGiftTypes = AcceptedGiftTypes(),
+) : ExtendedChannelDirectMessagesChat {
+    @SerialName(isDirectMessagesField)
+    @EncodeDefault
+    override val isDirectMessages: Boolean = true
+}
+
 @Serializable
 data class ExtendedBot(
     @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/chat/ExtendedAbstracts.kt

@@ -114,6 +114,12 @@ sealed interface ExtendedSupergroupChat : SupergroupChat, ExtendedGroupChat, Ext
 @Serializable(ExtendedChatSerializer.Companion::class)
 sealed interface ExtendedForumChat : ExtendedSupergroupChat, ForumChat
 
+@Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+@Serializable(PreviewChatSerializer::class)
+sealed interface ExtendedChannelDirectMessagesChat : ExtendedForumChat, ChannelDirectMessagesChat {
+    val channelChat: PreviewChannelChat
+}
+
 @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
 @Serializable(ExtendedChatSerializer.Companion::class)
 sealed interface ExtendedChatWithUsername : UsernameChat, ExtendedChat {

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/chat/Impls.kt

@@ -5,6 +5,7 @@ import dev.inmo.micro_utils.language_codes.IetfLangSerializer
 import dev.inmo.tgbotapi.types.*
 import dev.inmo.tgbotapi.types.abstracts.WithOptionalLanguageCode
 import dev.inmo.tgbotapi.utils.RiskFeature
+import kotlinx.serialization.EncodeDefault
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
@@ -70,6 +71,23 @@ data class ForumChatImpl(
     override val username: Username? = null
 ) : PreviewForumChat
 
+@Serializable
+@RiskFeature("This class is a subject of changes. It is better to use ForumChat due")
+data class ChannelDirectMessagesChatImpl(
+    @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+    @SerialName(idField)
+    override val id: IdChatIdentifier,
+    @SerialName(titleField)
+    override val title: String,
+    @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+    @SerialName(usernameField)
+    override val username: Username? = null
+) : PreviewChannelDirectMessagesChat {
+    @SerialName(isDirectMessagesField)
+    @EncodeDefault
+    override val isDirectMessages: Boolean = true
+}
+
 @Serializable
 @RiskFeature("This class is a subject of changes. It is better to use ChannelChat due")
 data class ChannelChatImpl(

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/chat/PreviewAbstracts.kt

@@ -40,3 +40,7 @@ sealed interface PreviewSupergroupChat : PreviewGroupChat, PreviewSuperPublicCha
 @Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
 @Serializable(PreviewChatSerializer::class)
 sealed interface PreviewForumChat : PreviewSupergroupChat, ForumChat
+
+@Suppress("SERIALIZER_TYPE_INCOMPATIBLE")
+@Serializable(PreviewChatSerializer::class)
+sealed interface PreviewChannelDirectMessagesChat : PreviewForumChat, ChannelDirectMessagesChat

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/ChatEvents/abstracts/ChannelDirectMessagesEvent.kt

@@ -1,3 +1,3 @@
 package dev.inmo.tgbotapi.types.message.ChatEvents.abstracts
 
-interface ChannelDirectMessagesEvent : SupergroupEvent
+interface ChannelDirectMessagesEvent : ForumEvent

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/ChatEvents/suggested/SuggestedPostApprovalFailed.kt

@@ -1,8 +1,7 @@
-package dev.inmo.tgbotapi.types.message.ChatEvents
+package dev.inmo.tgbotapi.types.message.ChatEvents.suggested
 
 import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChannelDirectMessagesEvent
-import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.CommonEvent
-import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.message.abstracts.ChannelDirectMessagesContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.TelegramBotAPIMessageDeserializeOnlySerializer
 import dev.inmo.tgbotapi.types.payments.SuggestedPostPrice
 import dev.inmo.tgbotapi.types.suggestedPostMessageField
@@ -16,5 +15,5 @@ data class SuggestedPostApprovalFailed(
     val price: SuggestedPostPrice,
     @SerialName(suggestedPostMessageField)
     @Serializable(TelegramBotAPIMessageDeserializeOnlySerializer::class)
-    val suggestedPostMessage: Message? = null,
+    val suggestedPostMessage: ChannelDirectMessagesContentMessage<*>? = null,
 ) : ChannelDirectMessagesEvent

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/ChatEvents/suggested/SuggestedPostApproved.kt

@@ -1,9 +1,8 @@
-package dev.inmo.tgbotapi.types.message.ChatEvents
+package dev.inmo.tgbotapi.types.message.ChatEvents.suggested
 
 import dev.inmo.tgbotapi.types.TelegramDate
 import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChannelDirectMessagesEvent
-import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.CommonEvent
-import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.message.abstracts.ChannelDirectMessagesContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.TelegramBotAPIMessageDeserializeOnlySerializer
 import dev.inmo.tgbotapi.types.payments.SuggestedPostPrice
 import dev.inmo.tgbotapi.types.suggestedPostMessageField
@@ -18,7 +17,7 @@ data class SuggestedPostApproved(
     val sendDate: TelegramDate,
     @SerialName(suggestedPostMessageField)
     @Serializable(TelegramBotAPIMessageDeserializeOnlySerializer::class)
-    val suggestedPostMessage: Message? = null,
+    val suggestedPostMessage: ChannelDirectMessagesContentMessage<*>? = null,
     @SerialName(priceField)
     val price: SuggestedPostPrice? = null,
 ) : ChannelDirectMessagesEvent

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/ChatEvents/suggested/SuggestedPostDeclined.kt

@@ -1,10 +1,9 @@
-package dev.inmo.tgbotapi.types.message.ChatEvents
+package dev.inmo.tgbotapi.types.message.ChatEvents.suggested
 
-import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.CommonEvent
-import dev.inmo.tgbotapi.types.message.abstracts.Message
 import dev.inmo.tgbotapi.types.suggestedPostMessageField
 import dev.inmo.tgbotapi.types.commentField
 import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChannelDirectMessagesEvent
+import dev.inmo.tgbotapi.types.message.abstracts.ChannelDirectMessagesContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.TelegramBotAPIMessageDeserializeOnlySerializer
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
@@ -13,7 +12,7 @@ import kotlinx.serialization.Serializable
 data class SuggestedPostDeclined(
     @SerialName(suggestedPostMessageField)
     @Serializable(TelegramBotAPIMessageDeserializeOnlySerializer::class)
-    val suggestedPostMessage: Message? = null,
+    val suggestedPostMessage: ChannelDirectMessagesContentMessage<*>? = null,
     @SerialName(commentField)
     val comment: String? = null
 ) : ChannelDirectMessagesEvent

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/ChatEvents/suggested/SuggestedPostInfo.kt

@@ -1,12 +1,14 @@
-package dev.inmo.tgbotapi.types.message
+package dev.inmo.tgbotapi.types.message.ChatEvents.suggested
 
+import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChannelDirectMessagesEvent
 import dev.inmo.tgbotapi.types.payments.SuggestedPostPrice
-import dev.inmo.tgbotapi.types.stateField
 import dev.inmo.tgbotapi.types.priceField
 import dev.inmo.tgbotapi.types.sendDateField
+import dev.inmo.tgbotapi.types.stateField
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.PrimitiveKind
 import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
@@ -21,7 +23,7 @@ data class SuggestedPostInfo(
     val price: SuggestedPostPrice? = null,
     @SerialName(sendDateField)
     val sendDate: Int? = null
-) {
+) : ChannelDirectMessagesEvent {
     @Serializable(State.Companion::class)
     sealed interface State {
         val name: String
@@ -37,7 +39,7 @@ data class SuggestedPostInfo(
 
         companion object : KSerializer<State> {
             override val descriptor: SerialDescriptor =
-                PrimitiveSerialDescriptor("SuggestedPostInfo.State", kotlinx.serialization.descriptors.PrimitiveKind.STRING)
+                PrimitiveSerialDescriptor("SuggestedPostInfo.State", PrimitiveKind.STRING)
 
             override fun serialize(encoder: Encoder, value: State) {
                 encoder.encodeString(value.name)
@@ -53,4 +55,4 @@ data class SuggestedPostInfo(
             }
         }
     }
-}
+}

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/ChatEvents/suggested/SuggestedPostPaid.kt

@@ -1,13 +1,11 @@
-package dev.inmo.tgbotapi.types.message.ChatEvents
+package dev.inmo.tgbotapi.types.message.ChatEvents.suggested
 
-import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.CommonEvent
-import dev.inmo.tgbotapi.types.message.abstracts.Message
 import dev.inmo.tgbotapi.types.payments.stars.StarAmount
 import dev.inmo.tgbotapi.types.suggestedPostMessageField
 import dev.inmo.tgbotapi.types.currencyField
 import dev.inmo.tgbotapi.types.amountField
 import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChannelDirectMessagesEvent
-import dev.inmo.tgbotapi.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
+import dev.inmo.tgbotapi.types.message.abstracts.ChannelDirectMessagesContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.TelegramBotAPIMessageDeserializeOnlySerializer
 import dev.inmo.tgbotapi.types.payments.abstracts.Currencied
 import dev.inmo.tgbotapi.types.payments.abstracts.Currency
@@ -26,7 +24,7 @@ import kotlinx.serialization.encoding.Encoder
 sealed interface SuggestedPostPaid : Currencied, ChannelDirectMessagesEvent {
     val amount: Long?
     val starAmount: StarAmount?
-    val suggestedPostMessage: Message?
+    val suggestedPostMessage: ChannelDirectMessagesContentMessage<*>?
 
     @Serializable
     data class XTR(
@@ -34,7 +32,7 @@ sealed interface SuggestedPostPaid : Currencied, ChannelDirectMessagesEvent {
         override val starAmount: StarAmount,
         @SerialName(suggestedPostMessageField)
         @Serializable(TelegramBotAPIMessageDeserializeOnlySerializer::class)
-        override val suggestedPostMessage: Message? = null,
+        override val suggestedPostMessage: ChannelDirectMessagesContentMessage<*>? = null,
     ) : SuggestedPostPaid {
         override val amount: Long?
             get() = null
@@ -47,7 +45,7 @@ sealed interface SuggestedPostPaid : Currencied, ChannelDirectMessagesEvent {
         override val amount: Long,
         @SerialName(suggestedPostMessageField)
         @Serializable(TelegramBotAPIMessageDeserializeOnlySerializer::class)
-        override val suggestedPostMessage: Message? = null
+        override val suggestedPostMessage: ChannelDirectMessagesContentMessage<*>? = null
     ) : SuggestedPostPaid {
         override val starAmount: StarAmount?
             get() = null
@@ -60,7 +58,7 @@ sealed interface SuggestedPostPaid : Currencied, ChannelDirectMessagesEvent {
         override val currency: Currency,
         @SerialName(suggestedPostMessageField)
         @Serializable(TelegramBotAPIMessageDeserializeOnlySerializer::class)
-        override val suggestedPostMessage: Message? = null,
+        override val suggestedPostMessage: ChannelDirectMessagesContentMessage<*>? = null,
         @SerialName(amountField)
         override val amount: Long? = null,
         @SerialName(starAmountField)

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/ChatEvents/suggested/SuggestedPostRefunded.kt

@@ -1,8 +1,7 @@
-package dev.inmo.tgbotapi.types.message.ChatEvents
+package dev.inmo.tgbotapi.types.message.ChatEvents.suggested
 
 import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChannelDirectMessagesEvent
-import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.CommonEvent
-import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.message.abstracts.ChannelDirectMessagesContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.TelegramBotAPIMessageDeserializeOnlySerializer
 import dev.inmo.tgbotapi.types.suggestedPostMessageField
 import dev.inmo.tgbotapi.types.reasonField
@@ -15,5 +14,5 @@ data class SuggestedPostRefunded(
     val reason: String,
     @SerialName(suggestedPostMessageField)
     @Serializable(TelegramBotAPIMessageDeserializeOnlySerializer::class)
-    val suggestedPostMessage: Message? = null
+    val suggestedPostMessage: ChannelDirectMessagesContentMessage<*>? = null
 ) : ChannelDirectMessagesEvent

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/CommonChannelDirectMessagesEventMessage.kt

@@ -0,0 +1,20 @@
+package dev.inmo.tgbotapi.types.message
+
+import korlibs.time.DateTime
+import dev.inmo.tgbotapi.types.MessageId
+import dev.inmo.tgbotapi.types.chat.PreviewChannelDirectMessagesChat
+import dev.inmo.tgbotapi.types.chat.PreviewSupergroupChat
+import dev.inmo.tgbotapi.types.chat.User
+import dev.inmo.tgbotapi.types.chat.SupergroupChat
+import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChannelDirectMessagesEvent
+import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.SupergroupEvent
+import dev.inmo.tgbotapi.types.message.abstracts.ChannelDirectMessagesEventMessage
+import dev.inmo.tgbotapi.types.message.abstracts.SupergroupEventMessage
+
+data class CommonChannelDirectMessagesEventMessage<T : ChannelDirectMessagesEvent>(
+    override val messageId: MessageId,
+    override val from: User,
+    override val chat: PreviewChannelDirectMessagesChat,
+    override val chatEvent: T,
+    override val date: DateTime
+) : ChannelDirectMessagesEventMessage<T>

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/GroupMessages.kt

@@ -276,6 +276,62 @@ data class FromChannelForumContentMessageImpl<T: MessageContent>(
     )
 }
 
+data class FromChannelChannelDirectMessagesContentMessageImpl<T: MessageContent>(
+    override val chat: PreviewChannelDirectMessagesChat,
+    override val channel: PreviewChannelChat,
+    override val messageId: MessageId,
+    override val threadId: MessageThreadId,
+    override val date: DateTime,
+    override val forwardOrigin: MessageOrigin?,
+    override val editDate: DateTime?,
+    override val hasProtectedContent: Boolean,
+    override val replyInfo: ReplyInfo?,
+    override val replyMarkup: InlineKeyboardMarkup?,
+    override val content: T,
+    override val senderBot: CommonBot?,
+    override val authorSignature: AuthorSignature?,
+    override val mediaGroupId: MediaGroupId?,
+    override val fromOffline: Boolean,
+    @SerialName(paidMessageStarCountField)
+    override val cost: Int? = null,
+) : FromChannelChannelDirectMessagesContentMessage<T> {
+    constructor(
+        chat: PreviewChannelDirectMessagesChat,
+        channel: PreviewChannelChat,
+        messageId: MessageId,
+        threadId: MessageThreadId,
+        date: DateTime,
+        forwardInfo: ForwardInfo,
+        editDate: DateTime?,
+        hasProtectedContent: Boolean,
+        replyTo: AccessibleMessage?,
+        replyMarkup: InlineKeyboardMarkup?,
+        content: T,
+        senderBot: CommonBot?,
+        authorSignature: AuthorSignature?,
+        mediaGroupId: MediaGroupId?,
+        fromOffline: Boolean,
+        cost: Int? = null,
+    ) : this(
+        chat = chat,
+        channel = channel,
+        messageId = messageId,
+        threadId = threadId,
+        date = date,
+        forwardOrigin = forwardInfo.messageOrigin(),
+        editDate = editDate,
+        hasProtectedContent = hasProtectedContent,
+        replyInfo = replyTo ?.let { ReplyInfo.Internal(it) },
+        replyMarkup = replyMarkup,
+        content = content,
+        senderBot = senderBot,
+        authorSignature = authorSignature,
+        mediaGroupId = mediaGroupId,
+        fromOffline = fromOffline,
+        cost = cost,
+    )
+}
+
 data class AnonymousForumContentMessageImpl<T : MessageContent>(
     override val chat: PreviewForumChat,
     override val messageId: MessageId,
@@ -384,3 +440,60 @@ data class CommonForumContentMessageImpl<T : MessageContent>(
         cost = cost,
     )
 }
+
+
+data class CommonChannelDirectMessagesContentMessageImpl<T : MessageContent>(
+    override val chat: PreviewChannelDirectMessagesChat,
+    override val messageId: MessageId,
+    override val threadId: MessageThreadId,
+    override val from: User,
+    override val date: DateTime,
+    override val forwardOrigin: MessageOrigin?,
+    override val editDate: DateTime?,
+    override val hasProtectedContent: Boolean,
+    override val replyInfo: ReplyInfo?,
+    override val replyMarkup: InlineKeyboardMarkup?,
+    override val content: T,
+    override val senderBot: CommonBot?,
+    override val mediaGroupId: MediaGroupId?,
+    override val senderBoostsCount: Int?,
+    override val fromOffline: Boolean,
+    @SerialName(paidMessageStarCountField)
+    override val cost: Int? = null,
+) : CommonChannelDirectMessagesContentMessage<T> {
+    constructor(
+        chat: PreviewChannelDirectMessagesChat,
+        messageId: MessageId,
+        threadId: MessageThreadId,
+        from: User,
+        date: DateTime,
+        forwardInfo: ForwardInfo,
+        editDate: DateTime?,
+        hasProtectedContent: Boolean,
+        replyTo: AccessibleMessage?,
+        replyMarkup: InlineKeyboardMarkup?,
+        content: T,
+        senderBot: CommonBot?,
+        mediaGroupId: MediaGroupId?,
+        senderBoostsCount: Int?,
+        fromOffline: Boolean,
+        cost: Int? = null,
+    ) : this(
+        chat = chat,
+        messageId = messageId,
+        threadId = threadId,
+        from = from,
+        date = date,
+        forwardOrigin = forwardInfo.messageOrigin(),
+        editDate = editDate,
+        hasProtectedContent = hasProtectedContent,
+        replyInfo = replyTo ?.let { ReplyInfo.Internal(it) },
+        replyMarkup = replyMarkup,
+        content = content,
+        senderBot = senderBot,
+        mediaGroupId = mediaGroupId,
+        senderBoostsCount = senderBoostsCount,
+        fromOffline = fromOffline,
+        cost = cost,
+    )
+}

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/RawMessage.kt

@@ -27,6 +27,12 @@ import dev.inmo.tgbotapi.types.message.ChatEvents.forum.ForumTopicReopened
 import dev.inmo.tgbotapi.types.message.ChatEvents.forum.GeneralForumTopicHidden
 import dev.inmo.tgbotapi.types.message.ChatEvents.forum.GeneralForumTopicUnhidden
 import dev.inmo.tgbotapi.types.message.ChatEvents.forum.WriteAccessAllowed
+import dev.inmo.tgbotapi.types.message.ChatEvents.suggested.SuggestedPostApprovalFailed
+import dev.inmo.tgbotapi.types.message.ChatEvents.suggested.SuggestedPostApproved
+import dev.inmo.tgbotapi.types.message.ChatEvents.suggested.SuggestedPostDeclined
+import dev.inmo.tgbotapi.types.message.ChatEvents.suggested.SuggestedPostInfo
+import dev.inmo.tgbotapi.types.message.ChatEvents.suggested.SuggestedPostPaid
+import dev.inmo.tgbotapi.types.message.ChatEvents.suggested.SuggestedPostRefunded
 import dev.inmo.tgbotapi.types.message.ChatEvents.voice.*
 import dev.inmo.tgbotapi.types.message.abstracts.*
 import dev.inmo.tgbotapi.types.message.content.*
@@ -183,6 +189,13 @@ internal data class RawMessage(
     // Channel direct messages
     private val direct_message_price_changed: ChannelDirectMessagesConfigurationChanged? = null,
 
+    //
+    private val suggested_post_approved: SuggestedPostApproved? = null,
+    private val suggested_post_approval_failed: SuggestedPostApprovalFailed? = null,
+    private val suggested_post_declined: SuggestedPostDeclined? = null,
+    private val suggested_post_paid: SuggestedPostPaid? = null,
+    private val suggested_post_refunded: SuggestedPostRefunded? = null,
+    private val suggested_post_info: SuggestedPostInfo? = null,
     // Gifts
     private val gift: GiftSentOrReceived.Regular? = null,
     private val unique_gift: GiftSentOrReceived.Unique? = null,
@@ -316,6 +329,12 @@ internal data class RawMessage(
             checklist_tasks_done != null -> checklist_tasks_done
             checklist_tasks_added != null -> checklist_tasks_added
             direct_message_price_changed != null -> direct_message_price_changed
+            suggested_post_info != null -> suggested_post_info
+            suggested_post_approved != null -> suggested_post_approved
+            suggested_post_approval_failed != null -> suggested_post_approval_failed
+            suggested_post_declined != null -> suggested_post_declined
+            suggested_post_paid != null -> suggested_post_paid
+            suggested_post_refunded != null -> suggested_post_refunded
             else -> null
         }
     }
@@ -345,6 +364,14 @@ internal data class RawMessage(
                         chatEvent as? GroupEvent ?: throwWrongChatEvent(GroupChat::class, chatEvent),
                         date.asDate
                     )
+                    is PreviewChannelDirectMessagesChat -> CommonChannelDirectMessagesEventMessage(
+                        messageId,
+                        //TODO:: Check that all channel direct messages events coming with "from" field
+                        checkedFrom ?: from ?: error("Channel direct messages events are expected to contain 'from' field"),
+                        chat,
+                        chatEvent as? ChannelDirectMessagesEvent ?: throwWrongChatEvent(PreviewChannelDirectMessagesChat::class, chatEvent),
+                        date.asDate
+                    )
                     is PreviewChannelChat -> ChannelEventMessage(
                         messageId,
                         chat,
@@ -388,141 +415,268 @@ internal data class RawMessage(
                             fromOffline = is_from_offline,
                             cost = paid_star_count,
                         )
-                        is PreviewForumChat -> if (messageThreadId != null) {
-                            val chatId = ChatIdWithThreadId(
-                                chat.id.chatId,
-                                messageThreadId
-                            )
-                            val actualForumChat = when (chat) {
-                                is ForumChatImpl -> chat.copy(id = chatId)
-                            }
-                            when (sender_chat) {
-                                is PreviewChannelChat -> FromChannelForumContentMessageImpl(
-                                    chat = actualForumChat,
-                                    channel = sender_chat,
-                                    messageId = messageId,
-                                    threadId = messageThreadId,
-                                    date = date.asDate,
-                                    forwardOrigin = forward_origin,
-                                    editDate = edit_date ?.asDate,
-                                    hasProtectedContent = has_protected_content == true,
-                                    replyInfo = replyInfo,
-                                    replyMarkup = reply_markup,
-                                    content = content,
-                                    senderBot = via_bot,
-                                    authorSignature = author_signature,
-                                    mediaGroupId = media_group_id,
-                                    fromOffline = is_from_offline,
-                                    cost = paid_star_count,
-                                )
-                                is PreviewGroupChat -> AnonymousForumContentMessageImpl(
-                                    chat = actualForumChat,
-                                    messageId = messageId,
-                                    threadId = messageThreadId,
-                                    date = date.asDate,
-                                    forwardOrigin = forward_origin,
-                                    editDate = edit_date ?.asDate,
-                                    hasProtectedContent = has_protected_content == true,
-                                    replyInfo = replyInfo,
-                                    replyMarkup = reply_markup,
-                                    content = content,
-                                    senderBot = via_bot,
-                                    authorSignature = author_signature,
-                                    mediaGroupId = media_group_id,
-                                    fromOffline = is_from_offline,
-                                    cost = paid_star_count,
-                                )
-                                null -> CommonForumContentMessageImpl(
-                                    chat = actualForumChat,
-                                    messageId = messageId,
-                                    threadId = messageThreadId,
-                                    from = checkedFrom ?: from ?: error("It is expected that in messages from non anonymous users and channels user must be specified"),
-                                    date = date.asDate,
-                                    forwardOrigin = forward_origin,
-                                    editDate = edit_date ?.asDate,
-                                    hasProtectedContent = has_protected_content == true,
-                                    replyInfo = replyInfo,
-                                    replyMarkup = reply_markup,
-                                    content = content,
-                                    senderBot = via_bot,
-                                    mediaGroupId = media_group_id,
-                                    senderBoostsCount = sender_boost_count,
-                                    fromOffline = is_from_offline,
-                                    cost = paid_star_count,
-                                )
-                            }
-                        } else {
-                            when (sender_chat) {
-                                is PreviewChannelChat -> if (is_automatic_forward == true) {
-                                    ConnectedFromChannelGroupContentMessageImpl(
-                                        chat = chat,
-                                        channel = sender_chat,
-                                        messageId = messageId,
-                                        date = date.asDate,
-                                        forwardOrigin = forward_origin,
-                                        editDate = edit_date ?.asDate,
-                                        hasProtectedContent = has_protected_content == true,
-                                        replyInfo = replyInfo,
-                                        replyMarkup = reply_markup,
-                                        content = content,
-                                        senderBot = via_bot,
-                                        authorSignature = author_signature,
-                                        mediaGroupId = media_group_id,
-                                        fromOffline = is_from_offline,
-                                        cost = paid_star_count,
+                        is PreviewForumChat -> when(chat) {
+                            is PreviewChannelDirectMessagesChat -> {
+                                if (messageThreadId != null) {
+                                    val chatId = ChatIdWithThreadId(
+                                        chat.id.chatId,
+                                        messageThreadId
                                     )
+                                    val actualForumChat = when (chat) {
+                                        is ChannelDirectMessagesChatImpl -> chat.copy(id = chatId)
+                                    }
+                                    when (sender_chat) {
+                                        is PreviewChannelChat -> FromChannelChannelDirectMessagesContentMessageImpl(
+                                            chat = actualForumChat,
+                                            channel = sender_chat,
+                                            messageId = messageId,
+                                            threadId = messageThreadId,
+                                            date = date.asDate,
+                                            forwardOrigin = forward_origin,
+                                            editDate = edit_date ?.asDate,
+                                            hasProtectedContent = has_protected_content == true,
+                                            replyInfo = replyInfo,
+                                            replyMarkup = reply_markup,
+                                            content = content,
+                                            senderBot = via_bot,
+                                            authorSignature = author_signature,
+                                            mediaGroupId = media_group_id,
+                                            fromOffline = is_from_offline,
+                                            cost = paid_star_count,
+                                        )
+                                        is PreviewGroupChat,
+                                        null -> CommonChannelDirectMessagesContentMessageImpl(
+                                            chat = actualForumChat,
+                                            messageId = messageId,
+                                            threadId = messageThreadId,
+                                            from = checkedFrom ?: from ?: error("It is expected that in direct channel messages from non anonymous channels user must be specified"),
+                                            date = date.asDate,
+                                            forwardOrigin = forward_origin,
+                                            editDate = edit_date ?.asDate,
+                                            hasProtectedContent = has_protected_content == true,
+                                            replyInfo = replyInfo,
+                                            replyMarkup = reply_markup,
+                                            content = content,
+                                            senderBot = via_bot,
+                                            mediaGroupId = media_group_id,
+                                            senderBoostsCount = sender_boost_count,
+                                            fromOffline = is_from_offline,
+                                            cost = paid_star_count,
+                                        )
+                                    }
                                 } else {
-                                    UnconnectedFromChannelGroupContentMessageImpl(
-                                        chat = chat,
-                                        channel = sender_chat,
-                                        messageId = messageId,
-                                        date = date.asDate,
-                                        forwardOrigin = forward_origin,
-                                        editDate = edit_date ?.asDate,
-                                        hasProtectedContent = has_protected_content == true,
-                                        replyInfo = replyInfo,
-                                        replyMarkup = reply_markup,
-                                        content = content,
-                                        senderBot = via_bot,
-                                        authorSignature = author_signature,
-                                        mediaGroupId = media_group_id,
-                                        fromOffline = is_from_offline,
-                                        cost = paid_star_count,
-                                    )
+                                    when (sender_chat) {
+                                        is PreviewChannelChat -> if (is_automatic_forward == true) {
+                                            ConnectedFromChannelGroupContentMessageImpl(
+                                                chat = chat,
+                                                channel = sender_chat,
+                                                messageId = messageId,
+                                                date = date.asDate,
+                                                forwardOrigin = forward_origin,
+                                                editDate = edit_date ?.asDate,
+                                                hasProtectedContent = has_protected_content == true,
+                                                replyInfo = replyInfo,
+                                                replyMarkup = reply_markup,
+                                                content = content,
+                                                senderBot = via_bot,
+                                                authorSignature = author_signature,
+                                                mediaGroupId = media_group_id,
+                                                fromOffline = is_from_offline,
+                                                cost = paid_star_count,
+                                            )
+                                        } else {
+                                            UnconnectedFromChannelGroupContentMessageImpl(
+                                                chat = chat,
+                                                channel = sender_chat,
+                                                messageId = messageId,
+                                                date = date.asDate,
+                                                forwardOrigin = forward_origin,
+                                                editDate = edit_date ?.asDate,
+                                                hasProtectedContent = has_protected_content == true,
+                                                replyInfo = replyInfo,
+                                                replyMarkup = reply_markup,
+                                                content = content,
+                                                senderBot = via_bot,
+                                                authorSignature = author_signature,
+                                                mediaGroupId = media_group_id,
+                                                fromOffline = is_from_offline,
+                                                cost = paid_star_count,
+                                            )
+                                        }
+                                        is GroupChat -> AnonymousGroupContentMessageImpl(
+                                            chat = chat,
+                                            messageId = messageId,
+                                            date = date.asDate,
+                                            forwardOrigin = forward_origin,
+                                            editDate = edit_date ?.asDate,
+                                            hasProtectedContent = has_protected_content == true,
+                                            replyInfo = replyInfo,
+                                            replyMarkup = reply_markup,
+                                            content = content,
+                                            senderBot = via_bot,
+                                            authorSignature = author_signature,
+                                            mediaGroupId = media_group_id,
+                                            fromOffline = is_from_offline,
+                                            cost = paid_star_count,
+                                        )
+                                        null -> CommonGroupContentMessageImpl(
+                                            chat = chat,
+                                            messageId = messageId,
+                                            from = checkedFrom ?: from ?: error("It is expected that in messages from non anonymous users and channels user must be specified"),
+                                            date = date.asDate,
+                                            forwardOrigin = forward_origin,
+                                            editDate = edit_date ?.asDate,
+                                            hasProtectedContent = has_protected_content == true,
+                                            replyInfo = replyInfo,
+                                            replyMarkup = reply_markup,
+                                            content = content,
+                                            senderBot = via_bot,
+                                            mediaGroupId = media_group_id,
+                                            senderBoostsCount = sender_boost_count,
+                                            fromOffline = is_from_offline,
+                                            cost = paid_star_count,
+                                        )
+                                    }
+                                }
+                            }
+                            is ForumChatImpl -> {
+                                if (messageThreadId != null) {
+                                    val chatId = ChatIdWithThreadId(
+                                        chat.id.chatId,
+                                        messageThreadId
+                                    )
+                                    val actualForumChat = when (chat) {
+                                        is ForumChatImpl -> chat.copy(id = chatId)
+                                    }
+                                    when (sender_chat) {
+                                        is PreviewChannelChat -> FromChannelForumContentMessageImpl(
+                                            chat = actualForumChat,
+                                            channel = sender_chat,
+                                            messageId = messageId,
+                                            threadId = messageThreadId,
+                                            date = date.asDate,
+                                            forwardOrigin = forward_origin,
+                                            editDate = edit_date ?.asDate,
+                                            hasProtectedContent = has_protected_content == true,
+                                            replyInfo = replyInfo,
+                                            replyMarkup = reply_markup,
+                                            content = content,
+                                            senderBot = via_bot,
+                                            authorSignature = author_signature,
+                                            mediaGroupId = media_group_id,
+                                            fromOffline = is_from_offline,
+                                            cost = paid_star_count,
+                                        )
+                                        is PreviewGroupChat -> AnonymousForumContentMessageImpl(
+                                            chat = actualForumChat,
+                                            messageId = messageId,
+                                            threadId = messageThreadId,
+                                            date = date.asDate,
+                                            forwardOrigin = forward_origin,
+                                            editDate = edit_date ?.asDate,
+                                            hasProtectedContent = has_protected_content == true,
+                                            replyInfo = replyInfo,
+                                            replyMarkup = reply_markup,
+                                            content = content,
+                                            senderBot = via_bot,
+                                            authorSignature = author_signature,
+                                            mediaGroupId = media_group_id,
+                                            fromOffline = is_from_offline,
+                                            cost = paid_star_count,
+                                        )
+                                        null -> CommonForumContentMessageImpl(
+                                            chat = actualForumChat,
+                                            messageId = messageId,
+                                            threadId = messageThreadId,
+                                            from = checkedFrom ?: from ?: error("It is expected that in messages from non anonymous users and channels user must be specified"),
+                                            date = date.asDate,
+                                            forwardOrigin = forward_origin,
+                                            editDate = edit_date ?.asDate,
+                                            hasProtectedContent = has_protected_content == true,
+                                            replyInfo = replyInfo,
+                                            replyMarkup = reply_markup,
+                                            content = content,
+                                            senderBot = via_bot,
+                                            mediaGroupId = media_group_id,
+                                            senderBoostsCount = sender_boost_count,
+                                            fromOffline = is_from_offline,
+                                            cost = paid_star_count,
+                                        )
+                                    }
+                                } else {
+                                    when (sender_chat) {
+                                        is PreviewChannelChat -> if (is_automatic_forward == true) {
+                                            ConnectedFromChannelGroupContentMessageImpl(
+                                                chat = chat,
+                                                channel = sender_chat,
+                                                messageId = messageId,
+                                                date = date.asDate,
+                                                forwardOrigin = forward_origin,
+                                                editDate = edit_date ?.asDate,
+                                                hasProtectedContent = has_protected_content == true,
+                                                replyInfo = replyInfo,
+                                                replyMarkup = reply_markup,
+                                                content = content,
+                                                senderBot = via_bot,
+                                                authorSignature = author_signature,
+                                                mediaGroupId = media_group_id,
+                                                fromOffline = is_from_offline,
+                                                cost = paid_star_count,
+                                            )
+                                        } else {
+                                            UnconnectedFromChannelGroupContentMessageImpl(
+                                                chat = chat,
+                                                channel = sender_chat,
+                                                messageId = messageId,
+                                                date = date.asDate,
+                                                forwardOrigin = forward_origin,
+                                                editDate = edit_date ?.asDate,
+                                                hasProtectedContent = has_protected_content == true,
+                                                replyInfo = replyInfo,
+                                                replyMarkup = reply_markup,
+                                                content = content,
+                                                senderBot = via_bot,
+                                                authorSignature = author_signature,
+                                                mediaGroupId = media_group_id,
+                                                fromOffline = is_from_offline,
+                                                cost = paid_star_count,
+                                            )
+                                        }
+                                        is GroupChat -> AnonymousGroupContentMessageImpl(
+                                            chat = chat,
+                                            messageId = messageId,
+                                            date = date.asDate,
+                                            forwardOrigin = forward_origin,
+                                            editDate = edit_date ?.asDate,
+                                            hasProtectedContent = has_protected_content == true,
+                                            replyInfo = replyInfo,
+                                            replyMarkup = reply_markup,
+                                            content = content,
+                                            senderBot = via_bot,
+                                            authorSignature = author_signature,
+                                            mediaGroupId = media_group_id,
+                                            fromOffline = is_from_offline,
+                                            cost = paid_star_count,
+                                        )
+                                        null -> CommonGroupContentMessageImpl(
+                                            chat = chat,
+                                            messageId = messageId,
+                                            from = checkedFrom ?: from ?: error("It is expected that in messages from non anonymous users and channels user must be specified"),
+                                            date = date.asDate,
+                                            forwardOrigin = forward_origin,
+                                            editDate = edit_date ?.asDate,
+                                            hasProtectedContent = has_protected_content == true,
+                                            replyInfo = replyInfo,
+                                            replyMarkup = reply_markup,
+                                            content = content,
+                                            senderBot = via_bot,
+                                            mediaGroupId = media_group_id,
+                                            senderBoostsCount = sender_boost_count,
+                                            fromOffline = is_from_offline,
+                                            cost = paid_star_count,
+                                        )
+                                    }
                                 }
-                                is GroupChat -> AnonymousGroupContentMessageImpl(
-                                    chat = chat,
-                                    messageId = messageId,
-                                    date = date.asDate,
-                                    forwardOrigin = forward_origin,
-                                    editDate = edit_date ?.asDate,
-                                    hasProtectedContent = has_protected_content == true,
-                                    replyInfo = replyInfo,
-                                    replyMarkup = reply_markup,
-                                    content = content,
-                                    senderBot = via_bot,
-                                    authorSignature = author_signature,
-                                    mediaGroupId = media_group_id,
-                                    fromOffline = is_from_offline,
-                                    cost = paid_star_count,
-                                )
-                                null -> CommonGroupContentMessageImpl(
-                                    chat = chat,
-                                    messageId = messageId,
-                                    from = checkedFrom ?: from ?: error("It is expected that in messages from non anonymous users and channels user must be specified"),
-                                    date = date.asDate,
-                                    forwardOrigin = forward_origin,
-                                    editDate = edit_date ?.asDate,
-                                    hasProtectedContent = has_protected_content == true,
-                                    replyInfo = replyInfo,
-                                    replyMarkup = reply_markup,
-                                    content = content,
-                                    senderBot = via_bot,
-                                    mediaGroupId = media_group_id,
-                                    senderBoostsCount = sender_boost_count,
-                                    fromOffline = is_from_offline,
-                                    cost = paid_star_count,
-                                )
                             }
                         }
                         is PreviewGroupChat -> when (sender_chat) {

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/abstracts/ChannelDirectMessagesEventMessage.kt

@@ -0,0 +1,11 @@
+package dev.inmo.tgbotapi.types.message.abstracts
+
+import dev.inmo.tgbotapi.types.chat.PreviewChannelDirectMessagesChat
+import dev.inmo.tgbotapi.types.chat.PreviewGroupChat
+import dev.inmo.tgbotapi.types.chat.PreviewSupergroupChat
+import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.ChannelDirectMessagesEvent
+import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.SupergroupEvent
+
+interface ChannelDirectMessagesEventMessage<T : ChannelDirectMessagesEvent> : GroupEventMessage<T> {
+    override val chat: PreviewChannelDirectMessagesChat
+}

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/abstracts/GroupMessages.kt

@@ -22,6 +22,9 @@ sealed interface ForumContentMessage<T : MessageContent> : GroupContentMessage<T
         get() = (replyTo as? ChatEventMessage<*>) ?.chatEvent as? ForumTopicCreated
 }
 
+sealed interface ChannelDirectMessagesContentMessage<T : MessageContent> : ForumContentMessage<T>, PossiblyTopicMessage {
+    override val chat: PreviewChannelDirectMessagesChat
+}
 
 sealed interface FromChannelGroupContentMessage<T : MessageContent> : GroupContentMessage<T>, SignedMessage, WithSenderChatMessage {
     val channel: PreviewChannelChat
@@ -41,9 +44,13 @@ interface CommonGroupContentMessage<T : MessageContent> : GroupContentMessage<T>
 
 interface FromChannelForumContentMessage<T: MessageContent> : FromChannelGroupContentMessage<T>, ForumContentMessage<T>
 
+interface FromChannelChannelDirectMessagesContentMessage<T: MessageContent> : FromChannelGroupContentMessage<T>, ChannelDirectMessagesContentMessage<T>
+
 interface AnonymousForumContentMessage<T : MessageContent> : ForumContentMessage<T>, SignedMessage, WithSenderChatMessage {
     override val senderChat: PreviewGroupChat
         get() = chat
 }
 
 interface CommonForumContentMessage<T : MessageContent> : ForumContentMessage<T>, PotentiallyFromUserGroupContentMessage<T>, FromUserMessage
+
+interface CommonChannelDirectMessagesContentMessage<T : MessageContent> : ChannelDirectMessagesContentMessage<T>, PotentiallyFromUserGroupContentMessage<T>, FromUserMessage

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/utils/extensions/MediaGroupContentMessageCreator.kt

@@ -169,6 +169,24 @@ fun <T : MediaGroupPartContent> List<PossiblySentViaBotCommonMessage<T>>.asMedia
             fromOffline = sourceMessage.fromOffline,
             cost = sourceMessage.cost,
         )
+        is CommonChannelDirectMessagesContentMessage -> CommonChannelDirectMessagesContentMessageImpl(
+            chat = sourceMessage.chat,
+            messageId = sourceMessage.messageId,
+            threadId = sourceMessage.threadId,
+            from = sourceMessage.user,
+            date = sourceMessage.date,
+            forwardOrigin = sourceMessage.forwardOrigin,
+            editDate = sourceMessage.editDate,
+            hasProtectedContent = sourceMessage.hasProtectedContent,
+            replyInfo = sourceMessage.replyInfo,
+            replyMarkup = sourceMessage.replyMarkup,
+            content = content,
+            senderBot = sourceMessage.senderBot,
+            mediaGroupId = sourceMessage.mediaGroupId,
+            senderBoostsCount = sourceMessage.senderBoostsCount,
+            fromOffline = sourceMessage.fromOffline,
+            cost = sourceMessage.cost,
+        )
         is FromChannelForumContentMessage -> FromChannelForumContentMessageImpl(
             chat = sourceMessage.chat,
             channel = sourceMessage.channel,
@@ -187,5 +205,24 @@ fun <T : MediaGroupPartContent> List<PossiblySentViaBotCommonMessage<T>>.asMedia
             fromOffline = sourceMessage.fromOffline,
             cost = sourceMessage.cost,
         )
+
+        is FromChannelChannelDirectMessagesContentMessage -> FromChannelChannelDirectMessagesContentMessageImpl(
+            chat = sourceMessage.chat,
+            channel = sourceMessage.channel,
+            messageId = sourceMessage.messageId,
+            threadId = sourceMessage.threadId,
+            date = sourceMessage.date,
+            forwardOrigin = sourceMessage.forwardOrigin,
+            editDate = sourceMessage.editDate,
+            hasProtectedContent = sourceMessage.hasProtectedContent,
+            replyInfo = sourceMessage.replyInfo,
+            replyMarkup = sourceMessage.replyMarkup,
+            content = content,
+            senderBot = sourceMessage.senderBot,
+            authorSignature = sourceMessage.authorSignature,
+            mediaGroupId = sourceMessage.mediaGroupId,
+            fromOffline = sourceMessage.fromOffline,
+            cost = sourceMessage.cost,
+        )
     }
 }