diff --git a/CHANGELOG.md b/CHANGELOG.md
index 819a78f5..047891a3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,33 @@
 # Telegram Bot API for PHP Change Log
 
+## 0.21.1 June 12, 2026
+
+- New #200: Add `RichText` interface and 25 rich text types: `RichTextBold`, `RichTextItalic`, `RichTextUnderline`,
+  `RichTextStrikethrough`, `RichTextSpoiler`, `RichTextDateTime`, `RichTextTextMention`, `RichTextSubscript`,
+  `RichTextSuperscript`, `RichTextMarked`, `RichTextCode`, `RichTextCustomEmoji`, `RichTextMathematicalExpression`,
+  `RichTextUrl`, `RichTextEmailAddress`, `RichTextPhoneNumber`, `RichTextBankCardNumber`, `RichTextMention`,
+  `RichTextHashtag`, `RichTextCashtag`, `RichTextBotCommand`, `RichTextAnchor`, `RichTextAnchorLink`,
+  `RichTextReference`, `RichTextReferenceLink`.
+- New #200: Add `RichBlockCaption`, `RichBlockTableCell`, and `RichBlockListItem` types.
+- New #200: Add `RichBlock` interface and 21 rich block types: `RichBlockParagraph`, `RichBlockSectionHeading`,
+  `RichBlockPreformatted`, `RichBlockFooter`, `RichBlockDivider`, `RichBlockMathematicalExpression`,
+  `RichBlockAnchor`, `RichBlockList`, `RichBlockBlockQuotation`, `RichBlockPullQuotation`, `RichBlockCollage`,
+  `RichBlockSlideshow`, `RichBlockTable`, `RichBlockDetails`, `RichBlockMap`, `RichBlockAnimation`,
+  `RichBlockAudio`, `RichBlockPhoto`, `RichBlockVideo`, `RichBlockVoiceNote`, `RichBlockThinking`.
+- New #200: Add `RichMessage` type.
+- New #200: Add `InputRichMessage` and `InputRichMessageContent` types.
+- New #200: Add `SendRichMessage` and `SendRichMessageDraft` methods.
+- New #200: Add `richMessage` parameter to `EditMessageText` method.
+- New #200: Add `richMessage` field to `Message` type.
+- New #200: Add `supportsJoinRequestQueries` field to `User` type.
+- New #200: Add `guardBot` field to `ChatFullInfo` type.
+- New #200: Add `queryId` field to `ChatJoinRequest` type.
+- New #200: Add `AnswerChatJoinRequestQuery` and `SendChatJoinRequestWebApp` methods.
+- New #200: Add `Link` type.
+- New #200: Add `link` field to `PollMedia` type.
+- New #200: Add `InputMediaLink` type.
+- Enh #200: Make `text` parameter of `EditMessageText` method optional.
+
 ## 0.21 May 9, 2026
 
 - New #199: Add `supportsGuestQueries` field to `User` type.
diff --git a/README.md b/README.md
index 52ec9e79..2a31569e 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@
 
 The package provides a simple and convenient way to interact with the Telegram Bot API.
 
-✔️ Telegram Bot API 10.0 (May 8, 2026) is **fully supported**.
+✔️ Telegram Bot API 10.1 (June 11, 2026) is **fully supported**.
 
 ♻️ **Zero dependencies** — no third-party libraries, only native PHP.
 
diff --git a/src/Method/AnswerChatJoinRequestQuery.php b/src/Method/AnswerChatJoinRequestQuery.php
new file mode 100644
index 00000000..e074d1e5
--- /dev/null
+++ b/src/Method/AnswerChatJoinRequestQuery.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Method;
+
+use Phptg\BotApi\MethodInterface;
+use Phptg\BotApi\ParseResult\ValueProcessor\TrueValue;
+use Phptg\BotApi\Transport\HttpMethod;
+
+/**
+ * @see https://core.telegram.org/bots/api#answerchatjoinrequestquery
+ *
+ * @template-implements MethodInterface<true>
+ */
+final readonly class AnswerChatJoinRequestQuery implements MethodInterface
+{
+    public function __construct(
+        private string $chatJoinRequestQueryId,
+        private string $result,
+    ) {}
+
+    public function getHttpMethod(): HttpMethod
+    {
+        return HttpMethod::POST;
+    }
+
+    public function getApiMethod(): string
+    {
+        return 'answerChatJoinRequestQuery';
+    }
+
+    public function getData(): array
+    {
+        return [
+            'chat_join_request_query_id' => $this->chatJoinRequestQueryId,
+            'result' => $this->result,
+        ];
+    }
+
+    public function getResultType(): TrueValue
+    {
+        return new TrueValue();
+    }
+}
diff --git a/src/Method/SendChatJoinRequestWebApp.php b/src/Method/SendChatJoinRequestWebApp.php
new file mode 100644
index 00000000..dfff00ca
--- /dev/null
+++ b/src/Method/SendChatJoinRequestWebApp.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Method;
+
+use Phptg\BotApi\MethodInterface;
+use Phptg\BotApi\ParseResult\ValueProcessor\TrueValue;
+use Phptg\BotApi\Transport\HttpMethod;
+
+/**
+ * @see https://core.telegram.org/bots/api#sendchatjoinrequestwebapp
+ *
+ * @template-implements MethodInterface<true>
+ */
+final readonly class SendChatJoinRequestWebApp implements MethodInterface
+{
+    public function __construct(
+        private string $chatJoinRequestQueryId,
+        private string $webAppUrl,
+    ) {}
+
+    public function getHttpMethod(): HttpMethod
+    {
+        return HttpMethod::POST;
+    }
+
+    public function getApiMethod(): string
+    {
+        return 'sendChatJoinRequestWebApp';
+    }
+
+    public function getData(): array
+    {
+        return [
+            'chat_join_request_query_id' => $this->chatJoinRequestQueryId,
+            'web_app_url' => $this->webAppUrl,
+        ];
+    }
+
+    public function getResultType(): TrueValue
+    {
+        return new TrueValue();
+    }
+}
diff --git a/src/Method/SendRichMessage.php b/src/Method/SendRichMessage.php
new file mode 100644
index 00000000..3f7226c4
--- /dev/null
+++ b/src/Method/SendRichMessage.php
@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Method;
+
+use Phptg\BotApi\MethodInterface;
+use Phptg\BotApi\ParseResult\ValueProcessor\ObjectValue;
+use Phptg\BotApi\Transport\HttpMethod;
+use Phptg\BotApi\Type\ForceReply;
+use Phptg\BotApi\Type\InlineKeyboardMarkup;
+use Phptg\BotApi\Type\InputRichMessage;
+use Phptg\BotApi\Type\Message;
+use Phptg\BotApi\Type\ReplyKeyboardMarkup;
+use Phptg\BotApi\Type\ReplyKeyboardRemove;
+use Phptg\BotApi\Type\ReplyParameters;
+use Phptg\BotApi\Type\SuggestedPostParameters;
+
+/**
+ * @see https://core.telegram.org/bots/api#sendrichmessage
+ *
+ * @template-implements MethodInterface<Message>
+ */
+final readonly class SendRichMessage implements MethodInterface
+{
+    public function __construct(
+        private int|string $chatId,
+        private InputRichMessage $richMessage,
+        private ?string $businessConnectionId = null,
+        private ?int $messageThreadId = null,
+        private ?int $directMessagesTopicId = null,
+        private ?bool $disableNotification = null,
+        private ?bool $protectContent = null,
+        private ?bool $allowPaidBroadcast = null,
+        private ?string $messageEffectId = null,
+        private ?SuggestedPostParameters $suggestedPostParameters = null,
+        private ?ReplyParameters $replyParameters = null,
+        private InlineKeyboardMarkup|ReplyKeyboardMarkup|ReplyKeyboardRemove|ForceReply|null $replyMarkup = null,
+    ) {}
+
+    public function getHttpMethod(): HttpMethod
+    {
+        return HttpMethod::POST;
+    }
+
+    public function getApiMethod(): string
+    {
+        return 'sendRichMessage';
+    }
+
+    public function getData(): array
+    {
+        return array_filter(
+            [
+                'business_connection_id' => $this->businessConnectionId,
+                'chat_id' => $this->chatId,
+                'message_thread_id' => $this->messageThreadId,
+                'direct_messages_topic_id' => $this->directMessagesTopicId,
+                'rich_message' => $this->richMessage->toRequestArray(),
+                'disable_notification' => $this->disableNotification,
+                'protect_content' => $this->protectContent,
+                'allow_paid_broadcast' => $this->allowPaidBroadcast,
+                'message_effect_id' => $this->messageEffectId,
+                'suggested_post_parameters' => $this->suggestedPostParameters?->toRequestArray(),
+                'reply_parameters' => $this->replyParameters?->toRequestArray(),
+                'reply_markup' => $this->replyMarkup?->toRequestArray(),
+            ],
+            static fn(mixed $value): bool => $value !== null,
+        );
+    }
+
+    public function getResultType(): ObjectValue
+    {
+        return new ObjectValue(Message::class);
+    }
+}
diff --git a/src/Method/SendRichMessageDraft.php b/src/Method/SendRichMessageDraft.php
new file mode 100644
index 00000000..0004be16
--- /dev/null
+++ b/src/Method/SendRichMessageDraft.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Method;
+
+use Phptg\BotApi\MethodInterface;
+use Phptg\BotApi\ParseResult\ValueProcessor\TrueValue;
+use Phptg\BotApi\Transport\HttpMethod;
+use Phptg\BotApi\Type\InputRichMessage;
+
+/**
+ * @see https://core.telegram.org/bots/api#sendrichmessagedraft
+ *
+ * @template-implements MethodInterface<true>
+ */
+final readonly class SendRichMessageDraft implements MethodInterface
+{
+    public function __construct(
+        private int $chatId,
+        private int $draftId,
+        private InputRichMessage $richMessage,
+        private ?int $messageThreadId = null,
+    ) {}
+
+    public function getHttpMethod(): HttpMethod
+    {
+        return HttpMethod::POST;
+    }
+
+    public function getApiMethod(): string
+    {
+        return 'sendRichMessageDraft';
+    }
+
+    public function getData(): array
+    {
+        return array_filter(
+            [
+                'chat_id' => $this->chatId,
+                'message_thread_id' => $this->messageThreadId,
+                'draft_id' => $this->draftId,
+                'rich_message' => $this->richMessage->toRequestArray(),
+            ],
+            static fn(mixed $value): bool => $value !== null,
+        );
+    }
+
+    public function getResultType(): TrueValue
+    {
+        return new TrueValue();
+    }
+}
diff --git a/src/Method/UpdatingMessage/EditMessageText.php b/src/Method/UpdatingMessage/EditMessageText.php
index 2f407d3f..82cbfa50 100644
--- a/src/Method/UpdatingMessage/EditMessageText.php
+++ b/src/Method/UpdatingMessage/EditMessageText.php
@@ -8,6 +8,7 @@
 use Phptg\BotApi\Transport\HttpMethod;
 use Phptg\BotApi\MethodInterface;
 use Phptg\BotApi\Type\InlineKeyboardMarkup;
+use Phptg\BotApi\Type\InputRichMessage;
 use Phptg\BotApi\Type\LinkPreviewOptions;
 use Phptg\BotApi\Type\Message;
 use Phptg\BotApi\Type\MessageEntity;
@@ -23,7 +24,7 @@
      * @param MessageEntity[]|null $entities
      */
     public function __construct(
-        private string $text,
+        private ?string $text = null,
         private ?string $businessConnectionId = null,
         private int|string|null $chatId = null,
         private ?int $messageId = null,
@@ -32,6 +33,7 @@ public function __construct(
         private ?array $entities = null,
         private ?LinkPreviewOptions $linkPreviewOptions = null,
         private ?InlineKeyboardMarkup $replyMarkup = null,
+        private ?InputRichMessage $richMessage = null,
     ) {}
 
     public function getHttpMethod(): HttpMethod
@@ -59,6 +61,7 @@ public function getData(): array
                     $this->entities,
                 ),
                 'link_preview_options' => $this->linkPreviewOptions?->toRequestArray(),
+                'rich_message' => $this->richMessage?->toRequestArray(),
                 'reply_markup' => $this->replyMarkup?->toRequestArray(),
             ],
             static fn(mixed $value): bool => $value !== null,
diff --git a/src/ParseResult/ObjectFactory.php b/src/ParseResult/ObjectFactory.php
index 14a8a772..48e8bda4 100644
--- a/src/ParseResult/ObjectFactory.php
+++ b/src/ParseResult/ObjectFactory.php
@@ -13,6 +13,7 @@
 use ReflectionProperty;
 use Phptg\BotApi\ParseResult\ValueProcessor\BackgroundFillValue;
 use Phptg\BotApi\ParseResult\ValueProcessor\BackgroundTypeValue;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichBlockValue;
 use Phptg\BotApi\ParseResult\ValueProcessor\BooleanValue;
 use Phptg\BotApi\ParseResult\ValueProcessor\ChatBoostSourceValue;
 use Phptg\BotApi\ParseResult\ValueProcessor\ChatMemberValue;
@@ -28,6 +29,7 @@
 use Phptg\BotApi\ParseResult\ValueProcessor\ValueProcessorInterface;
 use Phptg\BotApi\Type\BackgroundFill;
 use Phptg\BotApi\Type\BackgroundType;
+use Phptg\BotApi\Type\RichBlock;
 use Phptg\BotApi\Type\ChatBoostSource;
 use Phptg\BotApi\Type\ChatMember;
 use Phptg\BotApi\Type\MessageOrigin;
@@ -165,6 +167,7 @@ private function getTypeMap(): array
                 'bool' => new BooleanValue(),
                 DateTimeImmutable::class => new DateValue(),
                 ChatBoostSource::class => new ChatBoostSourceValue(),
+                RichBlock::class => new RichBlockValue(),
                 BackgroundFill::class => new BackgroundFillValue(),
                 BackgroundType::class => new BackgroundTypeValue(),
                 ChatMember::class => new ChatMemberValue(),
diff --git a/src/ParseResult/ValueProcessor/RichBlockValue.php b/src/ParseResult/ValueProcessor/RichBlockValue.php
new file mode 100644
index 00000000..b45afe0f
--- /dev/null
+++ b/src/ParseResult/ValueProcessor/RichBlockValue.php
@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\ParseResult\ValueProcessor;
+
+use Phptg\BotApi\Type\RichBlock;
+use Phptg\BotApi\Type\RichBlockParagraph;
+use Phptg\BotApi\Type\RichBlockDivider;
+use Phptg\BotApi\Type\RichBlockAnchor;
+use Phptg\BotApi\Type\RichBlockBlockQuotation;
+use Phptg\BotApi\Type\RichBlockCollage;
+use Phptg\BotApi\Type\RichBlockSlideshow;
+use Phptg\BotApi\Type\RichBlockDetails;
+use Phptg\BotApi\Type\RichBlockAnimation;
+use Phptg\BotApi\Type\RichBlockAudio;
+use Phptg\BotApi\Type\RichBlockPhoto;
+use Phptg\BotApi\Type\RichBlockVideo;
+use Phptg\BotApi\Type\RichBlockThinking;
+use Phptg\BotApi\Type\RichBlockVoiceNote;
+use Phptg\BotApi\Type\RichBlockMap;
+use Phptg\BotApi\Type\RichBlockTable;
+use Phptg\BotApi\Type\RichBlockPullQuotation;
+use Phptg\BotApi\Type\RichBlockList;
+use Phptg\BotApi\Type\RichBlockMathematicalExpression;
+use Phptg\BotApi\Type\RichBlockFooter;
+use Phptg\BotApi\Type\RichBlockPreformatted;
+use Phptg\BotApi\Type\RichBlockSectionHeading;
+
+/**
+ * @template-extends InterfaceValue<RichBlock>
+ */
+final readonly class RichBlockValue extends InterfaceValue
+{
+    public function getTypeKey(): string
+    {
+        return 'type';
+    }
+
+    public function getClassMap(): array
+    {
+        return [
+            'paragraph' => RichBlockParagraph::class,
+            'heading' => RichBlockSectionHeading::class,
+            'pre' => RichBlockPreformatted::class,
+            'footer' => RichBlockFooter::class,
+            'divider' => RichBlockDivider::class,
+            'mathematical_expression' => RichBlockMathematicalExpression::class,
+            'anchor' => RichBlockAnchor::class,
+            'list' => RichBlockList::class,
+            'blockquote' => RichBlockBlockQuotation::class,
+            'pullquote' => RichBlockPullQuotation::class,
+            'collage' => RichBlockCollage::class,
+            'slideshow' => RichBlockSlideshow::class,
+            'table' => RichBlockTable::class,
+            'details' => RichBlockDetails::class,
+            'map' => RichBlockMap::class,
+            'animation' => RichBlockAnimation::class,
+            'audio' => RichBlockAudio::class,
+            'photo' => RichBlockPhoto::class,
+            'video' => RichBlockVideo::class,
+            'voice_note' => RichBlockVoiceNote::class,
+            'thinking' => RichBlockThinking::class,
+        ];
+    }
+
+    public function getUnknownTypeMessage(): string
+    {
+        return 'Unknown rich block type.';
+    }
+}
diff --git a/src/ParseResult/ValueProcessor/RichTextValue.php b/src/ParseResult/ValueProcessor/RichTextValue.php
new file mode 100644
index 00000000..d20e1cb5
--- /dev/null
+++ b/src/ParseResult/ValueProcessor/RichTextValue.php
@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\ParseResult\ValueProcessor;
+
+use Attribute;
+use Phptg\BotApi\ParseResult\InvalidTypeOfValueInResultException;
+use Phptg\BotApi\ParseResult\NotFoundKeyInResultException;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\ParseResult\TelegramParseResultException;
+use Phptg\BotApi\Type\RichText;
+use Phptg\BotApi\Type\RichTextBold;
+use Phptg\BotApi\Type\RichTextItalic;
+use Phptg\BotApi\Type\RichTextDateTime;
+use Phptg\BotApi\Type\RichTextCode;
+use Phptg\BotApi\Type\RichTextCustomEmoji;
+use Phptg\BotApi\Type\RichTextMathematicalExpression;
+use Phptg\BotApi\Type\RichTextAnchor;
+use Phptg\BotApi\Type\RichTextAnchorLink;
+use Phptg\BotApi\Type\RichTextReference;
+use Phptg\BotApi\Type\RichTextReferenceLink;
+use Phptg\BotApi\Type\RichTextBotCommand;
+use Phptg\BotApi\Type\RichTextCashtag;
+use Phptg\BotApi\Type\RichTextHashtag;
+use Phptg\BotApi\Type\RichTextMention;
+use Phptg\BotApi\Type\RichTextBankCardNumber;
+use Phptg\BotApi\Type\RichTextEmailAddress;
+use Phptg\BotApi\Type\RichTextPhoneNumber;
+use Phptg\BotApi\Type\RichTextUrl;
+use Phptg\BotApi\Type\RichTextMarked;
+use Phptg\BotApi\Type\RichTextSubscript;
+use Phptg\BotApi\Type\RichTextSuperscript;
+use Phptg\BotApi\Type\RichTextTextMention;
+use Phptg\BotApi\Type\RichTextSpoiler;
+use Phptg\BotApi\Type\RichTextStrikethrough;
+use Phptg\BotApi\Type\RichTextUnderline;
+
+use function array_map;
+use function is_array;
+use function is_string;
+
+/**
+ * @template-implements ValueProcessorInterface<string|array|RichText>
+ */
+#[Attribute(Attribute::TARGET_PARAMETER)]
+final readonly class RichTextValue implements ValueProcessorInterface
+{
+    /**
+     * @var array<string, class-string<RichText>>
+     */
+    private const CLASS_MAP = [
+        'bold' => RichTextBold::class,
+        'italic' => RichTextItalic::class,
+        'underline' => RichTextUnderline::class,
+        'strikethrough' => RichTextStrikethrough::class,
+        'spoiler' => RichTextSpoiler::class,
+        'date_time' => RichTextDateTime::class,
+        'text_mention' => RichTextTextMention::class,
+        'subscript' => RichTextSubscript::class,
+        'superscript' => RichTextSuperscript::class,
+        'marked' => RichTextMarked::class,
+        'code' => RichTextCode::class,
+        'custom_emoji' => RichTextCustomEmoji::class,
+        'mathematical_expression' => RichTextMathematicalExpression::class,
+        'url' => RichTextUrl::class,
+        'email_address' => RichTextEmailAddress::class,
+        'phone_number' => RichTextPhoneNumber::class,
+        'bank_card_number' => RichTextBankCardNumber::class,
+        'mention' => RichTextMention::class,
+        'hashtag' => RichTextHashtag::class,
+        'cashtag' => RichTextCashtag::class,
+        'bot_command' => RichTextBotCommand::class,
+        'anchor' => RichTextAnchor::class,
+        'anchor_link' => RichTextAnchorLink::class,
+        'reference' => RichTextReference::class,
+        'reference_link' => RichTextReferenceLink::class,
+    ];
+
+    public function process(mixed $value, ?string $key, ObjectFactory $objectFactory): string|array|RichText
+    {
+        if (is_string($value)) {
+            return $value;
+        }
+
+        if (is_array($value)) {
+            if (array_is_list($value)) {
+                return array_map(
+                    fn(mixed $item): string|array|RichText => $this->process($item, $key, $objectFactory),
+                    $value,
+                );
+            }
+            return $this->createObject($value, $key, $objectFactory);
+        }
+
+        throw new InvalidTypeOfValueInResultException($key, $value, 'string or array');
+    }
+
+    private function createObject(array $value, ?string $key, ObjectFactory $objectFactory): RichText
+    {
+        if (!isset($value['type'])) {
+            throw new NotFoundKeyInResultException('type');
+        }
+        if (!is_string($value['type'])) {
+            throw new InvalidTypeOfValueInResultException('type', $value['type'], 'string');
+        }
+        $className = self::CLASS_MAP[$value['type']]
+            ?? throw new TelegramParseResultException('Unknown rich text type.');
+        return $objectFactory->create($value, $key, $className);
+    }
+}
diff --git a/src/TelegramBotApi.php b/src/TelegramBotApi.php
index 632be497..9253d0b4 100644
--- a/src/TelegramBotApi.php
+++ b/src/TelegramBotApi.php
@@ -10,6 +10,7 @@
 use Psr\Log\LoggerInterface;
 use SensitiveParameter;
 use Phptg\BotApi\Method\AnswerCallbackQuery;
+use Phptg\BotApi\Method\AnswerChatJoinRequestQuery;
 use Phptg\BotApi\Method\ApproveChatJoinRequest;
 use Phptg\BotApi\Method\ApproveSuggestedPost;
 use Phptg\BotApi\Method\BanChatMember;
@@ -116,6 +117,9 @@
 use Phptg\BotApi\Method\SendVenue;
 use Phptg\BotApi\Method\SendVideo;
 use Phptg\BotApi\Method\SendVideoNote;
+use Phptg\BotApi\Method\SendChatJoinRequestWebApp;
+use Phptg\BotApi\Method\SendRichMessage;
+use Phptg\BotApi\Method\SendRichMessageDraft;
 use Phptg\BotApi\Method\SendVoice;
 use Phptg\BotApi\Method\SetBusinessAccountBio;
 use Phptg\BotApi\Method\SetBusinessAccountGiftSettings;
@@ -215,6 +219,7 @@
 use Phptg\BotApi\Type\PreparedKeyboardButton;
 use Phptg\BotApi\Type\InputChecklist;
 use Phptg\BotApi\Type\InputFile;
+use Phptg\BotApi\Type\InputRichMessage;
 use Phptg\BotApi\Type\InputMedia;
 use Phptg\BotApi\Type\InputMediaAudio;
 use Phptg\BotApi\Type\InputMediaDocument;
@@ -394,6 +399,14 @@ public function answerCallbackQuery(
         );
     }
 
+    /**
+     * @see https://core.telegram.org/bots/api#answerchatjoinrequestquery
+     */
+    public function answerChatJoinRequestQuery(string $chatJoinRequestQueryId, string $result): FailResult|true
+    {
+        return $this->call(new AnswerChatJoinRequestQuery($chatJoinRequestQueryId, $result));
+    }
+
     /**
      * @see https://core.telegram.org/bots/api#answerinlinequery
      *
@@ -1059,7 +1072,7 @@ public function editMessageReplyMarkup(
      * @param MessageEntity[]|null $entities
      */
     public function editMessageText(
-        string $text,
+        ?string $text = null,
         ?string $businessConnectionId = null,
         int|string|null $chatId = null,
         ?int $messageId = null,
@@ -1068,6 +1081,7 @@ public function editMessageText(
         ?array $entities = null,
         ?LinkPreviewOptions $linkPreviewOptions = null,
         ?InlineKeyboardMarkup $replyMarkup = null,
+        ?InputRichMessage $richMessage = null,
     ): FailResult|Message|true {
         return $this->call(
             new EditMessageText(
@@ -1080,6 +1094,7 @@ public function editMessageText(
                 $entities,
                 $linkPreviewOptions,
                 $replyMarkup,
+                $richMessage,
             ),
         );
     }
@@ -2936,6 +2951,68 @@ public function sendVoice(
         );
     }
 
+    /**
+     * @see https://core.telegram.org/bots/api#sendchatjoinrequestwebapp
+     */
+    public function sendChatJoinRequestWebApp(string $chatJoinRequestQueryId, string $webAppUrl): FailResult|true
+    {
+        return $this->call(new SendChatJoinRequestWebApp($chatJoinRequestQueryId, $webAppUrl));
+    }
+
+    /**
+     * @see https://core.telegram.org/bots/api#sendrichmessage
+     */
+    public function sendRichMessage(
+        int|string $chatId,
+        InputRichMessage $richMessage,
+        ?string $businessConnectionId = null,
+        ?int $messageThreadId = null,
+        ?int $directMessagesTopicId = null,
+        ?bool $disableNotification = null,
+        ?bool $protectContent = null,
+        ?bool $allowPaidBroadcast = null,
+        ?string $messageEffectId = null,
+        ?SuggestedPostParameters $suggestedPostParameters = null,
+        ?ReplyParameters $replyParameters = null,
+        InlineKeyboardMarkup|ReplyKeyboardMarkup|ReplyKeyboardRemove|ForceReply|null $replyMarkup = null,
+    ): FailResult|Message {
+        return $this->call(
+            new SendRichMessage(
+                $chatId,
+                $richMessage,
+                $businessConnectionId,
+                $messageThreadId,
+                $directMessagesTopicId,
+                $disableNotification,
+                $protectContent,
+                $allowPaidBroadcast,
+                $messageEffectId,
+                $suggestedPostParameters,
+                $replyParameters,
+                $replyMarkup,
+            ),
+        );
+    }
+
+    /**
+     * @see https://core.telegram.org/bots/api#sendrichmessagedraft
+     */
+    public function sendRichMessageDraft(
+        int $chatId,
+        int $draftId,
+        InputRichMessage $richMessage,
+        ?int $messageThreadId = null,
+    ): FailResult|true {
+        return $this->call(
+            new SendRichMessageDraft(
+                $chatId,
+                $draftId,
+                $richMessage,
+                $messageThreadId,
+            ),
+        );
+    }
+
     /**
      * @see https://core.telegram.org/bots/api#setbusinessaccountbio
      */
diff --git a/src/Type/ChatFullInfo.php b/src/Type/ChatFullInfo.php
index a1bf69d8..e5f8ac8e 100644
--- a/src/Type/ChatFullInfo.php
+++ b/src/Type/ChatFullInfo.php
@@ -74,5 +74,6 @@ public function __construct(
         public ?UniqueGiftColors $uniqueGiftColors = null,
         public ?int $paidMessageStarCount = null,
         public ?Audio $firstProfileAudio = null,
+        public ?User $guardBot = null,
     ) {}
 }
diff --git a/src/Type/ChatJoinRequest.php b/src/Type/ChatJoinRequest.php
index 18ff46fb..b82c891e 100644
--- a/src/Type/ChatJoinRequest.php
+++ b/src/Type/ChatJoinRequest.php
@@ -20,5 +20,6 @@ public function __construct(
         public DateTimeImmutable $date,
         public ?string $bio = null,
         public ?ChatInviteLink $inviteLink = null,
+        public ?string $queryId = null,
     ) {}
 }
diff --git a/src/Type/Inline/InputRichMessageContent.php b/src/Type/Inline/InputRichMessageContent.php
new file mode 100644
index 00000000..0ec35c41
--- /dev/null
+++ b/src/Type/Inline/InputRichMessageContent.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type\Inline;
+
+use Phptg\BotApi\Type\InputRichMessage;
+
+/**
+ * @see https://core.telegram.org/bots/api#inputrichmessagecontent
+ *
+ * @api
+ */
+final readonly class InputRichMessageContent implements InputMessageContent
+{
+    public function __construct(
+        public InputRichMessage $richMessage,
+    ) {}
+
+    public function toRequestArray(): array
+    {
+        return [
+            'rich_message' => $this->richMessage->toRequestArray(),
+        ];
+    }
+}
diff --git a/src/Type/InputMediaLink.php b/src/Type/InputMediaLink.php
new file mode 100644
index 00000000..85551ce8
--- /dev/null
+++ b/src/Type/InputMediaLink.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\FileCollector;
+
+/**
+ * @see https://core.telegram.org/bots/api#inputmedialink
+ *
+ * @api
+ */
+final readonly class InputMediaLink implements InputPollOptionMedia
+{
+    public function __construct(
+        public string $url,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'link';
+    }
+
+    public function toRequestArray(?FileCollector $fileCollector = null): array
+    {
+        return [
+            'type' => $this->getType(),
+            'url' => $this->url,
+        ];
+    }
+}
diff --git a/src/Type/InputRichMessage.php b/src/Type/InputRichMessage.php
new file mode 100644
index 00000000..08211e24
--- /dev/null
+++ b/src/Type/InputRichMessage.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#inputrichmessage
+ *
+ * @api
+ */
+final readonly class InputRichMessage
+{
+    public function __construct(
+        public ?string $html = null,
+        public ?string $markdown = null,
+        public ?true $isRtl = null,
+        public ?true $skipEntityDetection = null,
+    ) {}
+
+    public function toRequestArray(): array
+    {
+        return array_filter(
+            [
+                'html' => $this->html,
+                'markdown' => $this->markdown,
+                'is_rtl' => $this->isRtl,
+                'skip_entity_detection' => $this->skipEntityDetection,
+            ],
+            static fn(mixed $value): bool => $value !== null,
+        );
+    }
+}
diff --git a/src/Type/Link.php b/src/Type/Link.php
new file mode 100644
index 00000000..6c9fd6d3
--- /dev/null
+++ b/src/Type/Link.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#link
+ *
+ * @api
+ */
+final readonly class Link
+{
+    public function __construct(
+        public string $url,
+    ) {}
+}
diff --git a/src/Type/Message.php b/src/Type/Message.php
index 0ca89a60..13e9a6ea 100644
--- a/src/Type/Message.php
+++ b/src/Type/Message.php
@@ -149,5 +149,6 @@ public function __construct(
         public ?ManagedBotCreated $managedBotCreated = null,
         public ?PollOptionAdded $pollOptionAdded = null,
         public ?PollOptionDeleted $pollOptionDeleted = null,
+        public ?RichMessage $richMessage = null,
     ) {}
 }
diff --git a/src/Type/PollMedia.php b/src/Type/PollMedia.php
index f19492b9..f3d06560 100644
--- a/src/Type/PollMedia.php
+++ b/src/Type/PollMedia.php
@@ -28,5 +28,6 @@ public function __construct(
         public ?Sticker $sticker = null,
         public ?Venue $venue = null,
         public ?Video $video = null,
+        public ?Link $link = null,
     ) {}
 }
diff --git a/src/Type/RichBlock.php b/src/Type/RichBlock.php
new file mode 100644
index 00000000..9fe50676
--- /dev/null
+++ b/src/Type/RichBlock.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblock
+ *
+ * @api
+ */
+interface RichBlock
+{
+    public function getType(): string;
+}
diff --git a/src/Type/RichBlockAnchor.php b/src/Type/RichBlockAnchor.php
new file mode 100644
index 00000000..68cb2ff1
--- /dev/null
+++ b/src/Type/RichBlockAnchor.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockanchor
+ *
+ * @api
+ */
+final readonly class RichBlockAnchor implements RichBlock
+{
+    public function __construct(
+        public string $name,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'anchor';
+    }
+}
diff --git a/src/Type/RichBlockAnimation.php b/src/Type/RichBlockAnimation.php
new file mode 100644
index 00000000..fad7cd09
--- /dev/null
+++ b/src/Type/RichBlockAnimation.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockanimation
+ *
+ * @api
+ */
+final readonly class RichBlockAnimation implements RichBlock
+{
+    public function __construct(
+        public Animation $animation,
+        public ?true $hasSpoiler = null,
+        public ?RichBlockCaption $caption = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'animation';
+    }
+}
diff --git a/src/Type/RichBlockAudio.php b/src/Type/RichBlockAudio.php
new file mode 100644
index 00000000..7a0610b1
--- /dev/null
+++ b/src/Type/RichBlockAudio.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockaudio
+ *
+ * @api
+ */
+final readonly class RichBlockAudio implements RichBlock
+{
+    public function __construct(
+        public Audio $audio,
+        public ?RichBlockCaption $caption = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'audio';
+    }
+}
diff --git a/src/Type/RichBlockBlockQuotation.php b/src/Type/RichBlockBlockQuotation.php
new file mode 100644
index 00000000..cea7cf4f
--- /dev/null
+++ b/src/Type/RichBlockBlockQuotation.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\ArrayMap;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichBlockValue;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockblockquotation
+ *
+ * @api
+ */
+final readonly class RichBlockBlockQuotation implements RichBlock
+{
+    /**
+     * @param list<RichBlock> $blocks
+     */
+    public function __construct(
+        #[ArrayMap(RichBlockValue::class)]
+        public array $blocks,
+        #[RichTextValue]
+        public string|array|RichText|null $credit = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'blockquote';
+    }
+}
diff --git a/src/Type/RichBlockCaption.php b/src/Type/RichBlockCaption.php
new file mode 100644
index 00000000..6fe2738d
--- /dev/null
+++ b/src/Type/RichBlockCaption.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockcaption
+ *
+ * @api
+ */
+final readonly class RichBlockCaption
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        #[RichTextValue]
+        public string|array|RichText|null $credit = null,
+    ) {}
+}
diff --git a/src/Type/RichBlockCollage.php b/src/Type/RichBlockCollage.php
new file mode 100644
index 00000000..3ffd06aa
--- /dev/null
+++ b/src/Type/RichBlockCollage.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\ArrayMap;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichBlockValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockcollage
+ *
+ * @api
+ */
+final readonly class RichBlockCollage implements RichBlock
+{
+    /**
+     * @param list<RichBlock> $blocks
+     */
+    public function __construct(
+        #[ArrayMap(RichBlockValue::class)]
+        public array $blocks,
+        public ?RichBlockCaption $caption = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'collage';
+    }
+}
diff --git a/src/Type/RichBlockDetails.php b/src/Type/RichBlockDetails.php
new file mode 100644
index 00000000..83bca953
--- /dev/null
+++ b/src/Type/RichBlockDetails.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\ArrayMap;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichBlockValue;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockdetails
+ *
+ * @api
+ */
+final readonly class RichBlockDetails implements RichBlock
+{
+    /**
+     * @param list<RichBlock> $blocks
+     */
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $summary,
+        #[ArrayMap(RichBlockValue::class)]
+        public array $blocks,
+        public ?true $isOpen = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'details';
+    }
+}
diff --git a/src/Type/RichBlockDivider.php b/src/Type/RichBlockDivider.php
new file mode 100644
index 00000000..8c4f85a3
--- /dev/null
+++ b/src/Type/RichBlockDivider.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockdivider
+ *
+ * @api
+ */
+final readonly class RichBlockDivider implements RichBlock
+{
+    public function getType(): string
+    {
+        return 'divider';
+    }
+}
diff --git a/src/Type/RichBlockFooter.php b/src/Type/RichBlockFooter.php
new file mode 100644
index 00000000..63784aa8
--- /dev/null
+++ b/src/Type/RichBlockFooter.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockfooter
+ *
+ * @api
+ */
+final readonly class RichBlockFooter implements RichBlock
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'footer';
+    }
+}
diff --git a/src/Type/RichBlockList.php b/src/Type/RichBlockList.php
new file mode 100644
index 00000000..f0dbe7ef
--- /dev/null
+++ b/src/Type/RichBlockList.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\ArrayOfObjectsValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblocklist
+ *
+ * @api
+ */
+final readonly class RichBlockList implements RichBlock
+{
+    /**
+     * @param list<RichBlockListItem> $items
+     */
+    public function __construct(
+        #[ArrayOfObjectsValue(RichBlockListItem::class)]
+        public array $items,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'list';
+    }
+}
diff --git a/src/Type/RichBlockListItem.php b/src/Type/RichBlockListItem.php
new file mode 100644
index 00000000..547e20f9
--- /dev/null
+++ b/src/Type/RichBlockListItem.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\ArrayMap;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichBlockValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblocklistitem
+ *
+ * @api
+ */
+final readonly class RichBlockListItem
+{
+    /**
+     * @param list<RichBlock> $blocks
+     */
+    public function __construct(
+        public string $label,
+        #[ArrayMap(RichBlockValue::class)]
+        public array $blocks,
+        public ?true $hasCheckbox = null,
+        public ?true $isChecked = null,
+        public ?int $value = null,
+        public ?string $type = null,
+    ) {}
+}
diff --git a/src/Type/RichBlockMap.php b/src/Type/RichBlockMap.php
new file mode 100644
index 00000000..243ab61b
--- /dev/null
+++ b/src/Type/RichBlockMap.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockmap
+ *
+ * @api
+ */
+final readonly class RichBlockMap implements RichBlock
+{
+    public function __construct(
+        public Location $location,
+        public int $zoom,
+        public int $width,
+        public int $height,
+        public ?RichBlockCaption $caption = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'map';
+    }
+}
diff --git a/src/Type/RichBlockMathematicalExpression.php b/src/Type/RichBlockMathematicalExpression.php
new file mode 100644
index 00000000..212dc393
--- /dev/null
+++ b/src/Type/RichBlockMathematicalExpression.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockmathematicalexpression
+ *
+ * @api
+ */
+final readonly class RichBlockMathematicalExpression implements RichBlock
+{
+    public function __construct(
+        public string $expression,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'mathematical_expression';
+    }
+}
diff --git a/src/Type/RichBlockParagraph.php b/src/Type/RichBlockParagraph.php
new file mode 100644
index 00000000..a5fe24fe
--- /dev/null
+++ b/src/Type/RichBlockParagraph.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockparagraph
+ *
+ * @api
+ */
+final readonly class RichBlockParagraph implements RichBlock
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'paragraph';
+    }
+}
diff --git a/src/Type/RichBlockPhoto.php b/src/Type/RichBlockPhoto.php
new file mode 100644
index 00000000..0bcc708f
--- /dev/null
+++ b/src/Type/RichBlockPhoto.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\ArrayOfObjectsValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockphoto
+ *
+ * @api
+ */
+final readonly class RichBlockPhoto implements RichBlock
+{
+    /**
+     * @param list<PhotoSize> $photo
+     */
+    public function __construct(
+        #[ArrayOfObjectsValue(PhotoSize::class)]
+        public array $photo,
+        public ?true $hasSpoiler = null,
+        public ?RichBlockCaption $caption = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'photo';
+    }
+}
diff --git a/src/Type/RichBlockPreformatted.php b/src/Type/RichBlockPreformatted.php
new file mode 100644
index 00000000..750cc4bd
--- /dev/null
+++ b/src/Type/RichBlockPreformatted.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockpreformatted
+ *
+ * @api
+ */
+final readonly class RichBlockPreformatted implements RichBlock
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public ?string $language = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'pre';
+    }
+}
diff --git a/src/Type/RichBlockPullQuotation.php b/src/Type/RichBlockPullQuotation.php
new file mode 100644
index 00000000..b1a88fcc
--- /dev/null
+++ b/src/Type/RichBlockPullQuotation.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockpullquotation
+ *
+ * @api
+ */
+final readonly class RichBlockPullQuotation implements RichBlock
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        #[RichTextValue]
+        public string|array|RichText|null $credit = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'pullquote';
+    }
+}
diff --git a/src/Type/RichBlockSectionHeading.php b/src/Type/RichBlockSectionHeading.php
new file mode 100644
index 00000000..93ccf132
--- /dev/null
+++ b/src/Type/RichBlockSectionHeading.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblocksectionheading
+ *
+ * @api
+ */
+final readonly class RichBlockSectionHeading implements RichBlock
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public int $size,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'heading';
+    }
+}
diff --git a/src/Type/RichBlockSlideshow.php b/src/Type/RichBlockSlideshow.php
new file mode 100644
index 00000000..5d334fa4
--- /dev/null
+++ b/src/Type/RichBlockSlideshow.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\ArrayMap;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichBlockValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockslideshow
+ *
+ * @api
+ */
+final readonly class RichBlockSlideshow implements RichBlock
+{
+    /**
+     * @param list<RichBlock> $blocks
+     */
+    public function __construct(
+        #[ArrayMap(RichBlockValue::class)]
+        public array $blocks,
+        public ?RichBlockCaption $caption = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'slideshow';
+    }
+}
diff --git a/src/Type/RichBlockTable.php b/src/Type/RichBlockTable.php
new file mode 100644
index 00000000..829ea5b3
--- /dev/null
+++ b/src/Type/RichBlockTable.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\ArrayOfArraysOfObjectsValue;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblocktable
+ *
+ * @api
+ */
+final readonly class RichBlockTable implements RichBlock
+{
+    /**
+     * @param list<list<RichBlockTableCell>> $cells
+     */
+    public function __construct(
+        #[ArrayOfArraysOfObjectsValue(RichBlockTableCell::class)]
+        public array $cells,
+        public ?true $isBordered = null,
+        public ?true $isStriped = null,
+        #[RichTextValue]
+        public string|array|RichText|null $caption = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'table';
+    }
+}
diff --git a/src/Type/RichBlockTableCell.php b/src/Type/RichBlockTableCell.php
new file mode 100644
index 00000000..0a188422
--- /dev/null
+++ b/src/Type/RichBlockTableCell.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblocktablecell
+ *
+ * @api
+ */
+final readonly class RichBlockTableCell
+{
+    public function __construct(
+        public string $align,
+        public string $valign,
+        #[RichTextValue]
+        public string|array|RichText|null $text = null,
+        public ?true $isHeader = null,
+        public ?int $colspan = null,
+        public ?int $rowspan = null,
+    ) {}
+}
diff --git a/src/Type/RichBlockThinking.php b/src/Type/RichBlockThinking.php
new file mode 100644
index 00000000..54749300
--- /dev/null
+++ b/src/Type/RichBlockThinking.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockthinking
+ *
+ * @api
+ */
+final readonly class RichBlockThinking implements RichBlock
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'thinking';
+    }
+}
diff --git a/src/Type/RichBlockVideo.php b/src/Type/RichBlockVideo.php
new file mode 100644
index 00000000..e9c560df
--- /dev/null
+++ b/src/Type/RichBlockVideo.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockvideo
+ *
+ * @api
+ */
+final readonly class RichBlockVideo implements RichBlock
+{
+    public function __construct(
+        public Video $video,
+        public ?true $hasSpoiler = null,
+        public ?RichBlockCaption $caption = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'video';
+    }
+}
diff --git a/src/Type/RichBlockVoiceNote.php b/src/Type/RichBlockVoiceNote.php
new file mode 100644
index 00000000..ae4c0c11
--- /dev/null
+++ b/src/Type/RichBlockVoiceNote.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richblockvoicenote
+ *
+ * @api
+ */
+final readonly class RichBlockVoiceNote implements RichBlock
+{
+    public function __construct(
+        public Voice $voiceNote,
+        public ?RichBlockCaption $caption = null,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'voice_note';
+    }
+}
diff --git a/src/Type/RichMessage.php b/src/Type/RichMessage.php
new file mode 100644
index 00000000..1815847a
--- /dev/null
+++ b/src/Type/RichMessage.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\ArrayMap;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichBlockValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richmessage
+ *
+ * @api
+ */
+final readonly class RichMessage
+{
+    /**
+     * @param list<RichBlock> $blocks
+     */
+    public function __construct(
+        #[ArrayMap(RichBlockValue::class)]
+        public array $blocks,
+        public ?true $isRtl = null,
+    ) {}
+}
diff --git a/src/Type/RichText.php b/src/Type/RichText.php
new file mode 100644
index 00000000..0291085e
--- /dev/null
+++ b/src/Type/RichText.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtext
+ *
+ * @api
+ */
+interface RichText
+{
+    public function getType(): string;
+}
diff --git a/src/Type/RichTextAnchor.php b/src/Type/RichTextAnchor.php
new file mode 100644
index 00000000..077b7577
--- /dev/null
+++ b/src/Type/RichTextAnchor.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextanchor
+ *
+ * @api
+ */
+final readonly class RichTextAnchor implements RichText
+{
+    public function __construct(
+        public string $name,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'anchor';
+    }
+}
diff --git a/src/Type/RichTextAnchorLink.php b/src/Type/RichTextAnchorLink.php
new file mode 100644
index 00000000..7e33541b
--- /dev/null
+++ b/src/Type/RichTextAnchorLink.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextanchorlink
+ *
+ * @api
+ */
+final readonly class RichTextAnchorLink implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $anchorName,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'anchor_link';
+    }
+}
diff --git a/src/Type/RichTextBankCardNumber.php b/src/Type/RichTextBankCardNumber.php
new file mode 100644
index 00000000..e950950f
--- /dev/null
+++ b/src/Type/RichTextBankCardNumber.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextbankcardnumber
+ *
+ * @api
+ */
+final readonly class RichTextBankCardNumber implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $bankCardNumber,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'bank_card_number';
+    }
+}
diff --git a/src/Type/RichTextBold.php b/src/Type/RichTextBold.php
new file mode 100644
index 00000000..980b7249
--- /dev/null
+++ b/src/Type/RichTextBold.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextbold
+ *
+ * @api
+ */
+final readonly class RichTextBold implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'bold';
+    }
+}
diff --git a/src/Type/RichTextBotCommand.php b/src/Type/RichTextBotCommand.php
new file mode 100644
index 00000000..bee19a0a
--- /dev/null
+++ b/src/Type/RichTextBotCommand.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextbotcommand
+ *
+ * @api
+ */
+final readonly class RichTextBotCommand implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $botCommand,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'bot_command';
+    }
+}
diff --git a/src/Type/RichTextCashtag.php b/src/Type/RichTextCashtag.php
new file mode 100644
index 00000000..f4926486
--- /dev/null
+++ b/src/Type/RichTextCashtag.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextcashtag
+ *
+ * @api
+ */
+final readonly class RichTextCashtag implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $cashtag,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'cashtag';
+    }
+}
diff --git a/src/Type/RichTextCode.php b/src/Type/RichTextCode.php
new file mode 100644
index 00000000..a107f01a
--- /dev/null
+++ b/src/Type/RichTextCode.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextcode
+ *
+ * @api
+ */
+final readonly class RichTextCode implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'code';
+    }
+}
diff --git a/src/Type/RichTextCustomEmoji.php b/src/Type/RichTextCustomEmoji.php
new file mode 100644
index 00000000..4edfd540
--- /dev/null
+++ b/src/Type/RichTextCustomEmoji.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextcustomemoji
+ *
+ * @api
+ */
+final readonly class RichTextCustomEmoji implements RichText
+{
+    public function __construct(
+        public string $customEmojiId,
+        public string $alternativeText,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'custom_emoji';
+    }
+}
diff --git a/src/Type/RichTextDateTime.php b/src/Type/RichTextDateTime.php
new file mode 100644
index 00000000..283ca9c3
--- /dev/null
+++ b/src/Type/RichTextDateTime.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextdatetime
+ *
+ * @api
+ */
+final readonly class RichTextDateTime implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public int $unixTime,
+        public string $dateTimeFormat,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'date_time';
+    }
+}
diff --git a/src/Type/RichTextEmailAddress.php b/src/Type/RichTextEmailAddress.php
new file mode 100644
index 00000000..e8c84e81
--- /dev/null
+++ b/src/Type/RichTextEmailAddress.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextemailaddress
+ *
+ * @api
+ */
+final readonly class RichTextEmailAddress implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $emailAddress,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'email_address';
+    }
+}
diff --git a/src/Type/RichTextHashtag.php b/src/Type/RichTextHashtag.php
new file mode 100644
index 00000000..e527d425
--- /dev/null
+++ b/src/Type/RichTextHashtag.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtexthashtag
+ *
+ * @api
+ */
+final readonly class RichTextHashtag implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $hashtag,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'hashtag';
+    }
+}
diff --git a/src/Type/RichTextItalic.php b/src/Type/RichTextItalic.php
new file mode 100644
index 00000000..abe1b9be
--- /dev/null
+++ b/src/Type/RichTextItalic.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextitalic
+ *
+ * @api
+ */
+final readonly class RichTextItalic implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'italic';
+    }
+}
diff --git a/src/Type/RichTextMarked.php b/src/Type/RichTextMarked.php
new file mode 100644
index 00000000..c07e13ed
--- /dev/null
+++ b/src/Type/RichTextMarked.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextmarked
+ *
+ * @api
+ */
+final readonly class RichTextMarked implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'marked';
+    }
+}
diff --git a/src/Type/RichTextMathematicalExpression.php b/src/Type/RichTextMathematicalExpression.php
new file mode 100644
index 00000000..3499717e
--- /dev/null
+++ b/src/Type/RichTextMathematicalExpression.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextmathematicalexpression
+ *
+ * @api
+ */
+final readonly class RichTextMathematicalExpression implements RichText
+{
+    public function __construct(
+        public string $expression,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'mathematical_expression';
+    }
+}
diff --git a/src/Type/RichTextMention.php b/src/Type/RichTextMention.php
new file mode 100644
index 00000000..15b34386
--- /dev/null
+++ b/src/Type/RichTextMention.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextmention
+ *
+ * @api
+ */
+final readonly class RichTextMention implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $username,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'mention';
+    }
+}
diff --git a/src/Type/RichTextPhoneNumber.php b/src/Type/RichTextPhoneNumber.php
new file mode 100644
index 00000000..f099059a
--- /dev/null
+++ b/src/Type/RichTextPhoneNumber.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextphonenumber
+ *
+ * @api
+ */
+final readonly class RichTextPhoneNumber implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $phoneNumber,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'phone_number';
+    }
+}
diff --git a/src/Type/RichTextReference.php b/src/Type/RichTextReference.php
new file mode 100644
index 00000000..9e7e2d13
--- /dev/null
+++ b/src/Type/RichTextReference.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextreference
+ *
+ * @api
+ */
+final readonly class RichTextReference implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $name,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'reference';
+    }
+}
diff --git a/src/Type/RichTextReferenceLink.php b/src/Type/RichTextReferenceLink.php
new file mode 100644
index 00000000..5b77204b
--- /dev/null
+++ b/src/Type/RichTextReferenceLink.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextreferencelink
+ *
+ * @api
+ */
+final readonly class RichTextReferenceLink implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $referenceName,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'reference_link';
+    }
+}
diff --git a/src/Type/RichTextSpoiler.php b/src/Type/RichTextSpoiler.php
new file mode 100644
index 00000000..ea9461ad
--- /dev/null
+++ b/src/Type/RichTextSpoiler.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextspoiler
+ *
+ * @api
+ */
+final readonly class RichTextSpoiler implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'spoiler';
+    }
+}
diff --git a/src/Type/RichTextStrikethrough.php b/src/Type/RichTextStrikethrough.php
new file mode 100644
index 00000000..8f467c79
--- /dev/null
+++ b/src/Type/RichTextStrikethrough.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextstrikethrough
+ *
+ * @api
+ */
+final readonly class RichTextStrikethrough implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'strikethrough';
+    }
+}
diff --git a/src/Type/RichTextSubscript.php b/src/Type/RichTextSubscript.php
new file mode 100644
index 00000000..01a29845
--- /dev/null
+++ b/src/Type/RichTextSubscript.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextsubscript
+ *
+ * @api
+ */
+final readonly class RichTextSubscript implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'subscript';
+    }
+}
diff --git a/src/Type/RichTextSuperscript.php b/src/Type/RichTextSuperscript.php
new file mode 100644
index 00000000..c3f9ef1d
--- /dev/null
+++ b/src/Type/RichTextSuperscript.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextsuperscript
+ *
+ * @api
+ */
+final readonly class RichTextSuperscript implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'superscript';
+    }
+}
diff --git a/src/Type/RichTextTextMention.php b/src/Type/RichTextTextMention.php
new file mode 100644
index 00000000..769adfbb
--- /dev/null
+++ b/src/Type/RichTextTextMention.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtexttextmention
+ *
+ * @api
+ */
+final readonly class RichTextTextMention implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public User $user,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'text_mention';
+    }
+}
diff --git a/src/Type/RichTextUnderline.php b/src/Type/RichTextUnderline.php
new file mode 100644
index 00000000..e7350058
--- /dev/null
+++ b/src/Type/RichTextUnderline.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtextunderline
+ *
+ * @api
+ */
+final readonly class RichTextUnderline implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'underline';
+    }
+}
diff --git a/src/Type/RichTextUrl.php b/src/Type/RichTextUrl.php
new file mode 100644
index 00000000..7961859b
--- /dev/null
+++ b/src/Type/RichTextUrl.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Type;
+
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+
+/**
+ * @see https://core.telegram.org/bots/api#richtexturl
+ *
+ * @api
+ */
+final readonly class RichTextUrl implements RichText
+{
+    public function __construct(
+        #[RichTextValue]
+        public string|array|RichText $text,
+        public string $url,
+    ) {}
+
+    public function getType(): string
+    {
+        return 'url';
+    }
+}
diff --git a/src/Type/User.php b/src/Type/User.php
index a02384fe..ed7cdda6 100644
--- a/src/Type/User.php
+++ b/src/Type/User.php
@@ -29,6 +29,7 @@ public function __construct(
         public ?bool $hasTopicsEnabled = null,
         public ?bool $allowsUsersToCreateTopics = null,
         public ?bool $canManageBots = null,
+        public ?bool $supportsJoinRequestQueries = null,
     ) {}
 
     public function toRequestArray(): array
@@ -52,6 +53,7 @@ public function toRequestArray(): array
                 'has_topics_enabled' => $this->hasTopicsEnabled,
                 'allows_users_to_create_topics' => $this->allowsUsersToCreateTopics,
                 'can_manage_bots' => $this->canManageBots,
+                'supports_join_request_queries' => $this->supportsJoinRequestQueries,
             ],
             static fn(mixed $value): bool => $value !== null,
         );
diff --git a/tests/Method/AnswerChatJoinRequestQueryTest.php b/tests/Method/AnswerChatJoinRequestQueryTest.php
new file mode 100644
index 00000000..207b6060
--- /dev/null
+++ b/tests/Method/AnswerChatJoinRequestQueryTest.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Method;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\Method\AnswerChatJoinRequestQuery;
+use Phptg\BotApi\Tests\Support\TestHelper;
+use Phptg\BotApi\Transport\HttpMethod;
+
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class AnswerChatJoinRequestQueryTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $method = new AnswerChatJoinRequestQuery('qid1', 'approve');
+
+        assertSame(HttpMethod::POST, $method->getHttpMethod());
+        assertSame('answerChatJoinRequestQuery', $method->getApiMethod());
+        assertSame(
+            [
+                'chat_join_request_query_id' => 'qid1',
+                'result' => 'approve',
+            ],
+            $method->getData(),
+        );
+    }
+
+    public function testPrepareResult(): void
+    {
+        $method = new AnswerChatJoinRequestQuery('qid1', 'approve');
+
+        $preparedResult = TestHelper::createSuccessStubApi(true)->call($method);
+
+        assertTrue($preparedResult);
+    }
+}
diff --git a/tests/Method/SendChatJoinRequestWebAppTest.php b/tests/Method/SendChatJoinRequestWebAppTest.php
new file mode 100644
index 00000000..798043cd
--- /dev/null
+++ b/tests/Method/SendChatJoinRequestWebAppTest.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Method;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\Method\SendChatJoinRequestWebApp;
+use Phptg\BotApi\Tests\Support\TestHelper;
+use Phptg\BotApi\Transport\HttpMethod;
+
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class SendChatJoinRequestWebAppTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $method = new SendChatJoinRequestWebApp('qid1', 'https://example.com/app');
+
+        assertSame(HttpMethod::POST, $method->getHttpMethod());
+        assertSame('sendChatJoinRequestWebApp', $method->getApiMethod());
+        assertSame(
+            [
+                'chat_join_request_query_id' => 'qid1',
+                'web_app_url' => 'https://example.com/app',
+            ],
+            $method->getData(),
+        );
+    }
+
+    public function testPrepareResult(): void
+    {
+        $method = new SendChatJoinRequestWebApp('qid1', 'https://example.com/app');
+
+        $preparedResult = TestHelper::createSuccessStubApi(true)->call($method);
+
+        assertTrue($preparedResult);
+    }
+}
diff --git a/tests/Method/SendRichMessageDraftTest.php b/tests/Method/SendRichMessageDraftTest.php
new file mode 100644
index 00000000..00eea397
--- /dev/null
+++ b/tests/Method/SendRichMessageDraftTest.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Method;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\Method\SendRichMessageDraft;
+use Phptg\BotApi\Tests\Support\TestHelper;
+use Phptg\BotApi\Transport\HttpMethod;
+use Phptg\BotApi\Type\InputRichMessage;
+
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class SendRichMessageDraftTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $richMessage = new InputRichMessage(html: '<b>Hello</b>');
+        $method = new SendRichMessageDraft(12, 1, $richMessage);
+
+        assertSame(HttpMethod::POST, $method->getHttpMethod());
+        assertSame('sendRichMessageDraft', $method->getApiMethod());
+        assertSame(
+            [
+                'chat_id' => 12,
+                'draft_id' => 1,
+                'rich_message' => $richMessage->toRequestArray(),
+            ],
+            $method->getData(),
+        );
+    }
+
+    public function testFull(): void
+    {
+        $richMessage = new InputRichMessage(html: '<b>Hello</b>', isRtl: true);
+        $method = new SendRichMessageDraft(12, 1, $richMessage, 99);
+
+        assertSame(
+            [
+                'chat_id' => 12,
+                'message_thread_id' => 99,
+                'draft_id' => 1,
+                'rich_message' => $richMessage->toRequestArray(),
+            ],
+            $method->getData(),
+        );
+    }
+
+    public function testPrepareResult(): void
+    {
+        $method = new SendRichMessageDraft(12, 1, new InputRichMessage(html: '<b>Hello</b>'));
+
+        $preparedResult = TestHelper::createSuccessStubApi(true)->call($method);
+
+        assertTrue($preparedResult);
+    }
+}
diff --git a/tests/Method/SendRichMessageTest.php b/tests/Method/SendRichMessageTest.php
new file mode 100644
index 00000000..9c7b11a8
--- /dev/null
+++ b/tests/Method/SendRichMessageTest.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Method;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\Method\SendRichMessage;
+use Phptg\BotApi\Tests\Support\TestHelper;
+use Phptg\BotApi\Transport\HttpMethod;
+use Phptg\BotApi\Type\ForceReply;
+use Phptg\BotApi\Type\InputRichMessage;
+use Phptg\BotApi\Type\ReplyParameters;
+use Phptg\BotApi\Type\SuggestedPostParameters;
+use Phptg\BotApi\Type\SuggestedPostPrice;
+
+use function PHPUnit\Framework\assertSame;
+
+final class SendRichMessageTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $method = new SendRichMessage(12, new InputRichMessage(html: '<b>Hello</b>'));
+
+        assertSame(HttpMethod::POST, $method->getHttpMethod());
+        assertSame('sendRichMessage', $method->getApiMethod());
+        assertSame(
+            [
+                'chat_id' => 12,
+                'rich_message' => ['html' => '<b>Hello</b>'],
+            ],
+            $method->getData(),
+        );
+    }
+
+    public function testFull(): void
+    {
+        $richMessage = new InputRichMessage(html: '<b>Hello</b>', isRtl: true);
+        $replyParameters = new ReplyParameters(23);
+        $replyMarkup = new ForceReply();
+        $suggestedPostParameters = new SuggestedPostParameters(new SuggestedPostPrice('USD', 10));
+        $method = new SendRichMessage(
+            12,
+            $richMessage,
+            'bcid1',
+            99,
+            123,
+            true,
+            false,
+            true,
+            'meid1',
+            $suggestedPostParameters,
+            $replyParameters,
+            $replyMarkup,
+        );
+
+        assertSame(
+            [
+                'business_connection_id' => 'bcid1',
+                'chat_id' => 12,
+                'message_thread_id' => 99,
+                'direct_messages_topic_id' => 123,
+                'rich_message' => ['html' => '<b>Hello</b>', 'is_rtl' => true],
+                'disable_notification' => true,
+                'protect_content' => false,
+                'allow_paid_broadcast' => true,
+                'message_effect_id' => 'meid1',
+                'suggested_post_parameters' => $suggestedPostParameters->toRequestArray(),
+                'reply_parameters' => $replyParameters->toRequestArray(),
+                'reply_markup' => $replyMarkup->toRequestArray(),
+            ],
+            $method->getData(),
+        );
+    }
+
+    public function testPrepareResult(): void
+    {
+        $method = new SendRichMessage(12, new InputRichMessage(html: '<b>Hello</b>'));
+
+        $preparedResult = TestHelper::createSuccessStubApi([
+            'message_id' => 7,
+            'date' => 1620000000,
+            'chat' => [
+                'id' => 1,
+                'type' => 'private',
+            ],
+        ])->call($method);
+
+        assertSame(7, $preparedResult->messageId);
+    }
+}
diff --git a/tests/Method/UpdatingMessage/EditMessageTextTest.php b/tests/Method/UpdatingMessage/EditMessageTextTest.php
index 593375dc..c9b41a34 100644
--- a/tests/Method/UpdatingMessage/EditMessageTextTest.php
+++ b/tests/Method/UpdatingMessage/EditMessageTextTest.php
@@ -11,6 +11,7 @@
 use Phptg\BotApi\Tests\Support\TestHelper;
 use Phptg\BotApi\Type\InlineKeyboardButton;
 use Phptg\BotApi\Type\InlineKeyboardMarkup;
+use Phptg\BotApi\Type\InputRichMessage;
 use Phptg\BotApi\Type\LinkPreviewOptions;
 use Phptg\BotApi\Type\Message;
 use Phptg\BotApi\Type\MessageEntity;
@@ -40,6 +41,7 @@ public function testFull(): void
         $messageEntity = new MessageEntity('bold', 0, 4);
         $linkPreviewOptions = new LinkPreviewOptions(true);
         $replyMarkup = new InlineKeyboardMarkup([[new InlineKeyboardButton('hello')]]);
+        $richMessage = new InputRichMessage(html: '<b>Hello</b>');
         $method = new EditMessageText(
             'test',
             'bcid1',
@@ -50,6 +52,7 @@ public function testFull(): void
             [$messageEntity],
             $linkPreviewOptions,
             $replyMarkup,
+            $richMessage,
         );
 
         assertSame(
@@ -62,6 +65,7 @@ public function testFull(): void
                 'parse_mode' => 'HTML',
                 'entities' => [$messageEntity->toRequestArray()],
                 'link_preview_options' => $linkPreviewOptions->toRequestArray(),
+                'rich_message' => $richMessage->toRequestArray(),
                 'reply_markup' => $replyMarkup->toRequestArray(),
             ],
             $method->getData(),
diff --git a/tests/ParseResult/ValueProcessor/RichBlockValueTest.php b/tests/ParseResult/ValueProcessor/RichBlockValueTest.php
new file mode 100644
index 00000000..fd0af026
--- /dev/null
+++ b/tests/ParseResult/ValueProcessor/RichBlockValueTest.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\ParseResult\ValueProcessor;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\ParseResult\TelegramParseResultException;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichBlockValue;
+use Phptg\BotApi\Type\RichBlockParagraph;
+
+use function PHPUnit\Framework\assertInstanceOf;
+
+final class RichBlockValueTest extends TestCase
+{
+    public function testParagraph(): void
+    {
+        $result = (new RichBlockValue())->process(
+            ['type' => 'paragraph', 'text' => 'hello'],
+            null,
+            new ObjectFactory(),
+        );
+
+        assertInstanceOf(RichBlockParagraph::class, $result);
+    }
+
+    public function testUnknown(): void
+    {
+        $processor = new RichBlockValue();
+        $objectFactory = new ObjectFactory();
+
+        $this->expectException(TelegramParseResultException::class);
+        $this->expectExceptionMessage('Unknown rich block type.');
+        $processor->process(['type' => 'unknown'], null, $objectFactory);
+    }
+}
diff --git a/tests/ParseResult/ValueProcessor/RichTextValueTest.php b/tests/ParseResult/ValueProcessor/RichTextValueTest.php
new file mode 100644
index 00000000..c9ad1c03
--- /dev/null
+++ b/tests/ParseResult/ValueProcessor/RichTextValueTest.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\ParseResult\ValueProcessor;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\InvalidTypeOfValueInResultException;
+use Phptg\BotApi\ParseResult\NotFoundKeyInResultException;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\ParseResult\TelegramParseResultException;
+use Phptg\BotApi\ParseResult\ValueProcessor\RichTextValue;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertEquals;
+use function PHPUnit\Framework\assertIsString;
+
+final class RichTextValueTest extends TestCase
+{
+    public function testString(): void
+    {
+        $result = (new RichTextValue())->process('hello', null, new ObjectFactory());
+
+        assertIsString($result);
+    }
+
+    public function testArray(): void
+    {
+        $result = (new RichTextValue())->process(
+            [
+                'hello',
+                ['type' => 'bold', 'text' => 'world'],
+            ],
+            null,
+            new ObjectFactory(),
+        );
+
+        assertEquals(['hello', new RichTextBold('world')], $result);
+    }
+
+    public function testRichText(): void
+    {
+        $result = (new RichTextValue())->process(
+            ['type' => 'bold', 'text' => 'hello'],
+            null,
+            new ObjectFactory(),
+        );
+
+        assertEquals(new RichTextBold('hello'), $result);
+    }
+
+    public function testInvalidType(): void
+    {
+        $processor = new RichTextValue();
+        $objectFactory = new ObjectFactory();
+
+        $this->expectException(InvalidTypeOfValueInResultException::class);
+        $this->expectExceptionMessage('Invalid type of value. Expected type is "string or array", but got "int".');
+        $processor->process(42, null, $objectFactory);
+    }
+
+    public function testMissingTypeKey(): void
+    {
+        $processor = new RichTextValue();
+        $objectFactory = new ObjectFactory();
+
+        $this->expectException(NotFoundKeyInResultException::class);
+        $this->expectExceptionMessage('Not found key "type" in result object.');
+        $processor->process(['foo' => 'bar'], null, $objectFactory);
+    }
+
+    public function testInvalidTypeKey(): void
+    {
+        $processor = new RichTextValue();
+        $objectFactory = new ObjectFactory();
+
+        $this->expectException(InvalidTypeOfValueInResultException::class);
+        $this->expectExceptionMessage(
+            'Invalid type of value for key "type". Expected type is "string", but got "int".',
+        );
+        $processor->process(['type' => 42], null, $objectFactory);
+    }
+
+    public function testUnknownType(): void
+    {
+        $processor = new RichTextValue();
+        $objectFactory = new ObjectFactory();
+
+        $this->expectException(TelegramParseResultException::class);
+        $this->expectExceptionMessage('Unknown rich text type.');
+        $processor->process(['type' => 'unknown'], null, $objectFactory);
+    }
+}
diff --git a/tests/TelegramBotApi/TelegramBotApiTest.php b/tests/TelegramBotApi/TelegramBotApiTest.php
index 00ef28c7..047fb26c 100644
--- a/tests/TelegramBotApi/TelegramBotApiTest.php
+++ b/tests/TelegramBotApi/TelegramBotApiTest.php
@@ -35,6 +35,7 @@
 use Phptg\BotApi\Type\SentGuestMessage;
 use Phptg\BotApi\Type\InputChecklist;
 use Phptg\BotApi\Type\InputFile;
+use Phptg\BotApi\Type\InputRichMessage;
 use Phptg\BotApi\Type\InputMediaPhoto;
 use Phptg\BotApi\Type\InputProfilePhotoStatic;
 use Phptg\BotApi\Type\InputStoryContentPhoto;
@@ -498,6 +499,15 @@ public function testAnswerCallbackQuery(): void
         assertTrue($result);
     }
 
+    public function testAnswerChatJoinRequestQuery(): void
+    {
+        $api = TestHelper::createSuccessStubApi(true);
+
+        $result = $api->answerChatJoinRequestQuery('qid1', 'approve');
+
+        assertTrue($result);
+    }
+
     public function testAnswerGuestQuery(): void
     {
         $api = TestHelper::createSuccessStubApi([
@@ -2322,6 +2332,41 @@ public function testSendVoice(): void
         assertSame(7, $result->messageId);
     }
 
+    public function testSendChatJoinRequestWebApp(): void
+    {
+        $api = TestHelper::createSuccessStubApi(true);
+
+        $result = $api->sendChatJoinRequestWebApp('qid1', 'https://example.com/app');
+
+        assertTrue($result);
+    }
+
+    public function testSendRichMessage(): void
+    {
+        $api = TestHelper::createSuccessStubApi([
+            'message_id' => 7,
+            'date' => 1620000000,
+            'chat' => [
+                'id' => 1,
+                'type' => 'private',
+            ],
+        ]);
+
+        $result = $api->sendRichMessage(12, new InputRichMessage(html: '<b>Hello</b>'));
+
+        assertInstanceOf(Message::class, $result);
+        assertSame(7, $result->messageId);
+    }
+
+    public function testSendRichMessageDraft(): void
+    {
+        $api = TestHelper::createSuccessStubApi(true);
+
+        $result = $api->sendRichMessageDraft(12, 1, new InputRichMessage(html: '<b>Hello</b>'));
+
+        assertTrue($result);
+    }
+
     public function testSetChatAdministratorCustomTitle(): void
     {
         $api = TestHelper::createSuccessStubApi(true);
diff --git a/tests/Type/ChatFullInfoTest.php b/tests/Type/ChatFullInfoTest.php
index f5c5f8f4..09e68b8d 100644
--- a/tests/Type/ChatFullInfoTest.php
+++ b/tests/Type/ChatFullInfoTest.php
@@ -20,6 +20,7 @@
 use Phptg\BotApi\Type\ReactionTypeCustomEmoji;
 use Phptg\BotApi\Type\Audio;
 use Phptg\BotApi\Type\UniqueGiftColors;
+use Phptg\BotApi\Type\User;
 use Phptg\BotApi\Type\UserRating;
 
 use function PHPUnit\Framework\assertCount;
@@ -87,6 +88,7 @@ public function testBase(): void
         assertNull($info->uniqueGiftColors);
         assertNull($info->paidMessageStarCount);
         assertNull($info->firstProfileAudio);
+        assertNull($info->guardBot);
     }
 
     public function testFromTelegramResult(): void
@@ -213,6 +215,11 @@ public function testFromTelegramResult(): void
                 'dark_theme_other_colors' => [0x2A2A2A, 0x3A3A3A],
             ],
             'paid_message_star_count' => 100,
+            'guard_bot' => [
+                'id' => 42,
+                'is_bot' => true,
+                'first_name' => 'GuardBot',
+            ],
         ], null, ChatFullInfo::class);
 
         assertSame(23, $info->id);
@@ -314,5 +321,9 @@ public function testFromTelegramResult(): void
         assertSame(180, $info->firstProfileAudio->duration);
         assertSame('Artist', $info->firstProfileAudio->performer);
         assertSame('Song', $info->firstProfileAudio->title);
+
+        assertInstanceOf(User::class, $info->guardBot);
+        assertSame(42, $info->guardBot->id);
+        assertSame('GuardBot', $info->guardBot->firstName);
     }
 }
diff --git a/tests/Type/ChatJoinRequestTest.php b/tests/Type/ChatJoinRequestTest.php
index 2b6719e3..5abaabf6 100644
--- a/tests/Type/ChatJoinRequestTest.php
+++ b/tests/Type/ChatJoinRequestTest.php
@@ -31,6 +31,7 @@ public function testBase(): void
         assertSame($date, $chatJoinRequest->date);
         assertNull($chatJoinRequest->bio);
         assertNull($chatJoinRequest->inviteLink);
+        assertNull($chatJoinRequest->queryId);
     }
 
     public function testFromTelegramResult(): void
@@ -59,6 +60,7 @@ public function testFromTelegramResult(): void
                 'is_primary' => false,
                 'is_revoked' => false,
             ],
+            'query_id' => 'qid123',
         ];
 
         $chatJoinRequest = (new ObjectFactory())->create($result, null, ChatJoinRequest::class);
@@ -75,5 +77,7 @@ public function testFromTelegramResult(): void
 
         assertInstanceOf(ChatInviteLink::class, $chatJoinRequest->inviteLink);
         assertSame('https://t.me/joinchat/x1', $chatJoinRequest->inviteLink->inviteLink);
+
+        assertSame('qid123', $chatJoinRequest->queryId);
     }
 }
diff --git a/tests/Type/Inline/InputRichMessageContentTest.php b/tests/Type/Inline/InputRichMessageContentTest.php
new file mode 100644
index 00000000..83c8e849
--- /dev/null
+++ b/tests/Type/Inline/InputRichMessageContentTest.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type\Inline;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\Type\Inline\InputRichMessageContent;
+use Phptg\BotApi\Type\InputRichMessage;
+
+use function PHPUnit\Framework\assertSame;
+
+final class InputRichMessageContentTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $richMessage = new InputRichMessage(html: '<b>Hello</b>');
+        $content = new InputRichMessageContent($richMessage);
+
+        assertSame($richMessage, $content->richMessage);
+        assertSame(
+            [
+                'rich_message' => ['html' => '<b>Hello</b>'],
+            ],
+            $content->toRequestArray(),
+        );
+    }
+}
diff --git a/tests/Type/InputMediaLinkTest.php b/tests/Type/InputMediaLinkTest.php
new file mode 100644
index 00000000..f1ffc994
--- /dev/null
+++ b/tests/Type/InputMediaLinkTest.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\FileCollector;
+use Phptg\BotApi\Type\InputMediaLink;
+
+use function PHPUnit\Framework\assertEmpty;
+use function PHPUnit\Framework\assertSame;
+
+final class InputMediaLinkTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $inputMedia = new InputMediaLink('https://example.com');
+
+        assertSame('link', $inputMedia->getType());
+        assertSame(
+            [
+                'type' => 'link',
+                'url' => 'https://example.com',
+            ],
+            $inputMedia->toRequestArray(),
+        );
+    }
+
+    public function testBaseWithFileCollector(): void
+    {
+        $inputMedia = new InputMediaLink('https://example.com');
+
+        $fileCollector = new FileCollector();
+        assertSame(
+            [
+                'type' => 'link',
+                'url' => 'https://example.com',
+            ],
+            $inputMedia->toRequestArray($fileCollector),
+        );
+        assertEmpty($fileCollector->get());
+    }
+}
diff --git a/tests/Type/InputRichMessageTest.php b/tests/Type/InputRichMessageTest.php
new file mode 100644
index 00000000..05ab0594
--- /dev/null
+++ b/tests/Type/InputRichMessageTest.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\Type\InputRichMessage;
+
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class InputRichMessageTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $message = new InputRichMessage();
+
+        assertNull($message->html);
+        assertNull($message->markdown);
+        assertNull($message->isRtl);
+        assertNull($message->skipEntityDetection);
+        assertSame([], $message->toRequestArray());
+    }
+
+    public function testFull(): void
+    {
+        $message = new InputRichMessage(
+            html: '<b>Hello</b>',
+            markdown: '**Hello**',
+            isRtl: true,
+            skipEntityDetection: true,
+        );
+
+        assertSame('<b>Hello</b>', $message->html);
+        assertSame('**Hello**', $message->markdown);
+        assertTrue($message->isRtl);
+        assertTrue($message->skipEntityDetection);
+        assertSame(
+            [
+                'html' => '<b>Hello</b>',
+                'markdown' => '**Hello**',
+                'is_rtl' => true,
+                'skip_entity_detection' => true,
+            ],
+            $message->toRequestArray(),
+        );
+    }
+}
diff --git a/tests/Type/LinkTest.php b/tests/Type/LinkTest.php
new file mode 100644
index 00000000..304b7177
--- /dev/null
+++ b/tests/Type/LinkTest.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\Link;
+
+use function PHPUnit\Framework\assertSame;
+
+final class LinkTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $link = new Link('https://example.com');
+
+        assertSame('https://example.com', $link->url);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $link = (new ObjectFactory())->create([
+            'url' => 'https://example.com',
+        ], null, Link::class);
+
+        assertSame('https://example.com', $link->url);
+    }
+}
diff --git a/tests/Type/MessageTest.php b/tests/Type/MessageTest.php
index aafd4dee..4471912f 100644
--- a/tests/Type/MessageTest.php
+++ b/tests/Type/MessageTest.php
@@ -20,6 +20,7 @@
 use Phptg\BotApi\Type\GeneralForumTopicUnhidden;
 use Phptg\BotApi\Type\GiveawayCreated;
 use Phptg\BotApi\Type\Message;
+use Phptg\BotApi\Type\RichMessage;
 use Phptg\BotApi\Type\MessageOriginHiddenUser;
 use Phptg\BotApi\Type\PaidMediaPhoto;
 use Phptg\BotApi\Type\Payment\RefundedPayment;
@@ -263,6 +264,11 @@ public function testFromTelegramResult(): void
                 'send_date' => 1640995200,
             ],
             'effect_id' => 'e235',
+            'rich_message' => [
+                'blocks' => [
+                    ['type' => 'paragraph', 'text' => 'hello'],
+                ],
+            ],
             'animation' => [
                 'file_id' => 'an1',
                 'file_unique_id' => 'fu1',
@@ -737,6 +743,7 @@ public function testFromTelegramResult(): void
 
         assertSame('https://example.com/lpo', $message->linkPreviewOptions?->url);
         assertSame('e235', $message->effectId);
+        assertInstanceOf(RichMessage::class, $message->richMessage);
         assertSame('an1', $message->animation?->fileId);
         assertSame('f2', $message->audio?->fileId);
         assertSame('f3', $message->document?->fileId);
diff --git a/tests/Type/PollMediaTest.php b/tests/Type/PollMediaTest.php
index b88cc376..f24fef69 100644
--- a/tests/Type/PollMediaTest.php
+++ b/tests/Type/PollMediaTest.php
@@ -6,9 +6,11 @@
 
 use PHPUnit\Framework\TestCase;
 use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\Link;
 use Phptg\BotApi\Type\PollMedia;
 
 use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
 use function PHPUnit\Framework\assertNull;
 use function PHPUnit\Framework\assertSame;
 
@@ -27,6 +29,7 @@ public function testBase(): void
         assertNull($pollMedia->sticker);
         assertNull($pollMedia->venue);
         assertNull($pollMedia->video);
+        assertNull($pollMedia->link);
     }
 
     public function testFromTelegramResult(): void
@@ -97,6 +100,9 @@ public function testFromTelegramResult(): void
                 'height' => 1080,
                 'duration' => 30,
             ],
+            'link' => [
+                'url' => 'https://example.com',
+            ],
         ], null, PollMedia::class);
 
         assertSame('animation_file_id', $pollMedia->animation?->fileId);
@@ -110,5 +116,7 @@ public function testFromTelegramResult(): void
         assertSame('sticker_file_id', $pollMedia->sticker?->fileId);
         assertSame('Kremlin', $pollMedia->venue?->title);
         assertSame('video_file_id', $pollMedia->video?->fileId);
+        assertInstanceOf(Link::class, $pollMedia->link);
+        assertSame('https://example.com', $pollMedia->link->url);
     }
 }
diff --git a/tests/Type/RichBlockAnchorTest.php b/tests/Type/RichBlockAnchorTest.php
new file mode 100644
index 00000000..38f8a4eb
--- /dev/null
+++ b/tests/Type/RichBlockAnchorTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockAnchor;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockAnchorTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $anchor = new RichBlockAnchor('section1');
+
+        assertSame('anchor', $anchor->getType());
+        assertSame('section1', $anchor->name);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $anchor = (new ObjectFactory())->create([
+            'type' => 'anchor',
+            'name' => 'section1',
+        ], null, RichBlockAnchor::class);
+
+        assertSame('anchor', $anchor->getType());
+        assertSame('section1', $anchor->name);
+    }
+}
diff --git a/tests/Type/RichBlockAnimationTest.php b/tests/Type/RichBlockAnimationTest.php
new file mode 100644
index 00000000..df9a4ea3
--- /dev/null
+++ b/tests/Type/RichBlockAnimationTest.php
@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\Animation;
+use Phptg\BotApi\Type\RichBlockAnimation;
+use Phptg\BotApi\Type\RichBlockCaption;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class RichBlockAnimationTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $animation = new Animation('f123', 'fullF123', 640, 480, 10);
+        $block = new RichBlockAnimation($animation);
+
+        assertSame('animation', $block->getType());
+        assertSame($animation, $block->animation);
+        assertNull($block->hasSpoiler);
+        assertNull($block->caption);
+    }
+
+    public function testFull(): void
+    {
+        $animation = new Animation('f123', 'fullF123', 640, 480, 10);
+        $caption = new RichBlockCaption('animation');
+        $block = new RichBlockAnimation($animation, true, $caption);
+
+        assertSame('animation', $block->getType());
+        assertTrue($block->hasSpoiler);
+        assertSame($caption, $block->caption);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'animation',
+            'animation' => [
+                'file_id' => 'f123',
+                'file_unique_id' => 'fullF123',
+                'width' => 640,
+                'height' => 480,
+                'duration' => 10,
+            ],
+        ], null, RichBlockAnimation::class);
+
+        assertSame('animation', $block->getType());
+        assertInstanceOf(Animation::class, $block->animation);
+        assertNull($block->hasSpoiler);
+        assertNull($block->caption);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'animation',
+            'animation' => [
+                'file_id' => 'f123',
+                'file_unique_id' => 'fullF123',
+                'width' => 640,
+                'height' => 480,
+                'duration' => 10,
+            ],
+            'has_spoiler' => true,
+            'caption' => ['text' => 'animation'],
+        ], null, RichBlockAnimation::class);
+
+        assertSame('animation', $block->getType());
+        assertInstanceOf(Animation::class, $block->animation);
+        assertTrue($block->hasSpoiler);
+        assertInstanceOf(RichBlockCaption::class, $block->caption);
+    }
+}
diff --git a/tests/Type/RichBlockAudioTest.php b/tests/Type/RichBlockAudioTest.php
new file mode 100644
index 00000000..17c95ede
--- /dev/null
+++ b/tests/Type/RichBlockAudioTest.php
@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\Audio;
+use Phptg\BotApi\Type\RichBlockAudio;
+use Phptg\BotApi\Type\RichBlockCaption;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockAudioTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $audio = new Audio('f123', 'fullF123', 180);
+        $block = new RichBlockAudio($audio);
+
+        assertSame('audio', $block->getType());
+        assertSame($audio, $block->audio);
+        assertNull($block->caption);
+    }
+
+    public function testFull(): void
+    {
+        $audio = new Audio('f123', 'fullF123', 180);
+        $caption = new RichBlockCaption('audio');
+        $block = new RichBlockAudio($audio, $caption);
+
+        assertSame('audio', $block->getType());
+        assertSame($caption, $block->caption);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'audio',
+            'audio' => [
+                'file_id' => 'f123',
+                'file_unique_id' => 'fullF123',
+                'duration' => 180,
+            ],
+        ], null, RichBlockAudio::class);
+
+        assertSame('audio', $block->getType());
+        assertInstanceOf(Audio::class, $block->audio);
+        assertNull($block->caption);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'audio',
+            'audio' => [
+                'file_id' => 'f123',
+                'file_unique_id' => 'fullF123',
+                'duration' => 180,
+            ],
+            'caption' => ['text' => 'audio'],
+        ], null, RichBlockAudio::class);
+
+        assertSame('audio', $block->getType());
+        assertInstanceOf(Audio::class, $block->audio);
+        assertInstanceOf(RichBlockCaption::class, $block->caption);
+    }
+}
diff --git a/tests/Type/RichBlockBlockQuotationTest.php b/tests/Type/RichBlockBlockQuotationTest.php
new file mode 100644
index 00000000..87dc3631
--- /dev/null
+++ b/tests/Type/RichBlockBlockQuotationTest.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockBlockQuotation;
+use Phptg\BotApi\Type\RichBlockParagraph;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockBlockQuotationTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $blockquote = new RichBlockBlockQuotation([new RichBlockParagraph('hello')]);
+
+        assertSame('blockquote', $blockquote->getType());
+        assertCount(1, $blockquote->blocks);
+        assertNull($blockquote->credit);
+    }
+
+    public function testFull(): void
+    {
+        $blockquote = new RichBlockBlockQuotation([new RichBlockParagraph('hello')], 'credit');
+
+        assertSame('blockquote', $blockquote->getType());
+        assertCount(1, $blockquote->blocks);
+        assertSame('credit', $blockquote->credit);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $blockquote = (new ObjectFactory())->create([
+            'type' => 'blockquote',
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+        ], null, RichBlockBlockQuotation::class);
+
+        assertSame('blockquote', $blockquote->getType());
+        assertCount(1, $blockquote->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $blockquote->blocks[0]);
+        assertNull($blockquote->credit);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $blockquote = (new ObjectFactory())->create([
+            'type' => 'blockquote',
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+            'credit' => ['type' => 'bold', 'text' => 'author'],
+        ], null, RichBlockBlockQuotation::class);
+
+        assertSame('blockquote', $blockquote->getType());
+        assertCount(1, $blockquote->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $blockquote->blocks[0]);
+        assertInstanceOf(RichTextBold::class, $blockquote->credit);
+        assertSame('author', $blockquote->credit->text);
+    }
+}
diff --git a/tests/Type/RichBlockCaptionTest.php b/tests/Type/RichBlockCaptionTest.php
new file mode 100644
index 00000000..149c2e35
--- /dev/null
+++ b/tests/Type/RichBlockCaptionTest.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockCaption;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockCaptionTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $caption = new RichBlockCaption('hello');
+
+        assertSame('hello', $caption->text);
+        assertNull($caption->credit);
+    }
+
+    public function testFull(): void
+    {
+        $caption = new RichBlockCaption('hello', 'world');
+
+        assertSame('hello', $caption->text);
+        assertSame('world', $caption->credit);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $caption = (new ObjectFactory())->create([
+            'text' => 'hello',
+        ], null, RichBlockCaption::class);
+
+        assertSame('hello', $caption->text);
+        assertNull($caption->credit);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $caption = (new ObjectFactory())->create([
+            'text' => 'hello',
+            'credit' => ['type' => 'bold', 'text' => 'world'],
+        ], null, RichBlockCaption::class);
+
+        assertSame('hello', $caption->text);
+        assertInstanceOf(RichTextBold::class, $caption->credit);
+        assertSame('world', $caption->credit->text);
+    }
+}
diff --git a/tests/Type/RichBlockCollageTest.php b/tests/Type/RichBlockCollageTest.php
new file mode 100644
index 00000000..bf1b02b3
--- /dev/null
+++ b/tests/Type/RichBlockCollageTest.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockCollage;
+use Phptg\BotApi\Type\RichBlockParagraph;
+use Phptg\BotApi\Type\RichBlockCaption;
+
+use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockCollageTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $collage = new RichBlockCollage([new RichBlockParagraph('hello')]);
+
+        assertSame('collage', $collage->getType());
+        assertCount(1, $collage->blocks);
+        assertNull($collage->caption);
+    }
+
+    public function testFull(): void
+    {
+        $caption = new RichBlockCaption('caption text');
+        $collage = new RichBlockCollage([new RichBlockParagraph('hello')], $caption);
+
+        assertSame('collage', $collage->getType());
+        assertCount(1, $collage->blocks);
+        assertSame($caption, $collage->caption);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $collage = (new ObjectFactory())->create([
+            'type' => 'collage',
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+        ], null, RichBlockCollage::class);
+
+        assertSame('collage', $collage->getType());
+        assertCount(1, $collage->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $collage->blocks[0]);
+        assertNull($collage->caption);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $collage = (new ObjectFactory())->create([
+            'type' => 'collage',
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+            'caption' => ['text' => 'caption text'],
+        ], null, RichBlockCollage::class);
+
+        assertSame('collage', $collage->getType());
+        assertCount(1, $collage->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $collage->blocks[0]);
+        assertInstanceOf(RichBlockCaption::class, $collage->caption);
+    }
+}
diff --git a/tests/Type/RichBlockDetailsTest.php b/tests/Type/RichBlockDetailsTest.php
new file mode 100644
index 00000000..822358b6
--- /dev/null
+++ b/tests/Type/RichBlockDetailsTest.php
@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockDetails;
+use Phptg\BotApi\Type\RichBlockParagraph;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class RichBlockDetailsTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $details = new RichBlockDetails('summary', [new RichBlockParagraph('hello')]);
+
+        assertSame('details', $details->getType());
+        assertSame('summary', $details->summary);
+        assertCount(1, $details->blocks);
+        assertNull($details->isOpen);
+    }
+
+    public function testFull(): void
+    {
+        $details = new RichBlockDetails('summary', [new RichBlockParagraph('hello')], true);
+
+        assertSame('details', $details->getType());
+        assertSame('summary', $details->summary);
+        assertCount(1, $details->blocks);
+        assertTrue($details->isOpen);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $details = (new ObjectFactory())->create([
+            'type' => 'details',
+            'summary' => 'summary',
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+        ], null, RichBlockDetails::class);
+
+        assertSame('details', $details->getType());
+        assertSame('summary', $details->summary);
+        assertCount(1, $details->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $details->blocks[0]);
+        assertNull($details->isOpen);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $details = (new ObjectFactory())->create([
+            'type' => 'details',
+            'summary' => ['type' => 'bold', 'text' => 'summary'],
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+            'is_open' => true,
+        ], null, RichBlockDetails::class);
+
+        assertSame('details', $details->getType());
+        assertInstanceOf(RichTextBold::class, $details->summary);
+        assertSame('summary', $details->summary->text);
+        assertCount(1, $details->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $details->blocks[0]);
+        assertTrue($details->isOpen);
+    }
+}
diff --git a/tests/Type/RichBlockDividerTest.php b/tests/Type/RichBlockDividerTest.php
new file mode 100644
index 00000000..4ce69325
--- /dev/null
+++ b/tests/Type/RichBlockDividerTest.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockDivider;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockDividerTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $divider = new RichBlockDivider();
+
+        assertSame('divider', $divider->getType());
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $divider = (new ObjectFactory())->create([
+            'type' => 'divider',
+        ], null, RichBlockDivider::class);
+
+        assertSame('divider', $divider->getType());
+    }
+}
diff --git a/tests/Type/RichBlockFooterTest.php b/tests/Type/RichBlockFooterTest.php
new file mode 100644
index 00000000..541c1206
--- /dev/null
+++ b/tests/Type/RichBlockFooterTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockFooter;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockFooterTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $footer = new RichBlockFooter('hello');
+
+        assertSame('footer', $footer->getType());
+        assertSame('hello', $footer->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $footer = (new ObjectFactory())->create([
+            'type' => 'footer',
+            'text' => 'hello',
+        ], null, RichBlockFooter::class);
+
+        assertSame('footer', $footer->getType());
+        assertSame('hello', $footer->text);
+    }
+}
diff --git a/tests/Type/RichBlockListItemTest.php b/tests/Type/RichBlockListItemTest.php
new file mode 100644
index 00000000..fa403bda
--- /dev/null
+++ b/tests/Type/RichBlockListItemTest.php
@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockListItem;
+use Phptg\BotApi\Type\RichBlockParagraph;
+
+use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class RichBlockListItemTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $item = new RichBlockListItem('1.', [new RichBlockParagraph('hello')]);
+
+        assertSame('1.', $item->label);
+        assertCount(1, $item->blocks);
+        assertNull($item->hasCheckbox);
+        assertNull($item->isChecked);
+        assertNull($item->value);
+        assertNull($item->type);
+    }
+
+    public function testFull(): void
+    {
+        $item = new RichBlockListItem('1.', [new RichBlockParagraph('hello')], true, true, 1, 'a');
+
+        assertSame('1.', $item->label);
+        assertTrue($item->hasCheckbox);
+        assertTrue($item->isChecked);
+        assertSame(1, $item->value);
+        assertSame('a', $item->type);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $item = (new ObjectFactory())->create([
+            'label' => '1.',
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+        ], null, RichBlockListItem::class);
+
+        assertSame('1.', $item->label);
+        assertCount(1, $item->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $item->blocks[0]);
+        assertNull($item->hasCheckbox);
+        assertNull($item->isChecked);
+        assertNull($item->value);
+        assertNull($item->type);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $item = (new ObjectFactory())->create([
+            'label' => '1.',
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+            'has_checkbox' => true,
+            'is_checked' => true,
+            'value' => 1,
+            'type' => 'a',
+        ], null, RichBlockListItem::class);
+
+        assertSame('1.', $item->label);
+        assertCount(1, $item->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $item->blocks[0]);
+        assertTrue($item->hasCheckbox);
+        assertTrue($item->isChecked);
+        assertSame(1, $item->value);
+        assertSame('a', $item->type);
+    }
+}
diff --git a/tests/Type/RichBlockListTest.php b/tests/Type/RichBlockListTest.php
new file mode 100644
index 00000000..076e6dd7
--- /dev/null
+++ b/tests/Type/RichBlockListTest.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockList;
+use Phptg\BotApi\Type\RichBlockListItem;
+
+use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockListTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $list = new RichBlockList([new RichBlockListItem('1.', [])]);
+
+        assertSame('list', $list->getType());
+        assertCount(1, $list->items);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $list = (new ObjectFactory())->create([
+            'type' => 'list',
+            'items' => [
+                ['label' => '1.', 'blocks' => []],
+                ['label' => '2.', 'blocks' => []],
+            ],
+        ], null, RichBlockList::class);
+
+        assertSame('list', $list->getType());
+        assertCount(2, $list->items);
+        assertInstanceOf(RichBlockListItem::class, $list->items[0]);
+        assertSame('1.', $list->items[0]->label);
+        assertSame('2.', $list->items[1]->label);
+    }
+}
diff --git a/tests/Type/RichBlockMapTest.php b/tests/Type/RichBlockMapTest.php
new file mode 100644
index 00000000..4df5d7c7
--- /dev/null
+++ b/tests/Type/RichBlockMapTest.php
@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\Location;
+use Phptg\BotApi\Type\RichBlockMap;
+use Phptg\BotApi\Type\RichBlockCaption;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockMapTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $location = new Location(55.75, 37.62);
+        $map = new RichBlockMap($location, 15, 800, 600);
+
+        assertSame('map', $map->getType());
+        assertSame($location, $map->location);
+        assertSame(15, $map->zoom);
+        assertSame(800, $map->width);
+        assertSame(600, $map->height);
+        assertNull($map->caption);
+    }
+
+    public function testFull(): void
+    {
+        $location = new Location(55.75, 37.62);
+        $caption = new RichBlockCaption('Moscow');
+        $map = new RichBlockMap($location, 15, 800, 600, $caption);
+
+        assertSame('map', $map->getType());
+        assertSame($location, $map->location);
+        assertSame(15, $map->zoom);
+        assertSame(800, $map->width);
+        assertSame(600, $map->height);
+        assertSame($caption, $map->caption);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $map = (new ObjectFactory())->create([
+            'type' => 'map',
+            'location' => ['latitude' => 55.75, 'longitude' => 37.62],
+            'zoom' => 15,
+            'width' => 800,
+            'height' => 600,
+        ], null, RichBlockMap::class);
+
+        assertSame('map', $map->getType());
+        assertInstanceOf(Location::class, $map->location);
+        assertSame(15, $map->zoom);
+        assertSame(800, $map->width);
+        assertSame(600, $map->height);
+        assertNull($map->caption);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $map = (new ObjectFactory())->create([
+            'type' => 'map',
+            'location' => ['latitude' => 55.75, 'longitude' => 37.62],
+            'zoom' => 15,
+            'width' => 800,
+            'height' => 600,
+            'caption' => ['text' => 'Moscow'],
+        ], null, RichBlockMap::class);
+
+        assertSame('map', $map->getType());
+        assertInstanceOf(Location::class, $map->location);
+        assertSame(15, $map->zoom);
+        assertSame(800, $map->width);
+        assertSame(600, $map->height);
+        assertInstanceOf(RichBlockCaption::class, $map->caption);
+    }
+}
diff --git a/tests/Type/RichBlockMathematicalExpressionTest.php b/tests/Type/RichBlockMathematicalExpressionTest.php
new file mode 100644
index 00000000..85a99673
--- /dev/null
+++ b/tests/Type/RichBlockMathematicalExpressionTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockMathematicalExpression;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockMathematicalExpressionTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $expression = new RichBlockMathematicalExpression('E = mc^2');
+
+        assertSame('mathematical_expression', $expression->getType());
+        assertSame('E = mc^2', $expression->expression);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $expression = (new ObjectFactory())->create([
+            'type' => 'mathematical_expression',
+            'expression' => 'E = mc^2',
+        ], null, RichBlockMathematicalExpression::class);
+
+        assertSame('mathematical_expression', $expression->getType());
+        assertSame('E = mc^2', $expression->expression);
+    }
+}
diff --git a/tests/Type/RichBlockParagraphTest.php b/tests/Type/RichBlockParagraphTest.php
new file mode 100644
index 00000000..a6ef7f89
--- /dev/null
+++ b/tests/Type/RichBlockParagraphTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockParagraph;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockParagraphTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $paragraph = new RichBlockParagraph('hello');
+
+        assertSame('paragraph', $paragraph->getType());
+        assertSame('hello', $paragraph->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $paragraph = (new ObjectFactory())->create([
+            'type' => 'paragraph',
+            'text' => 'hello',
+        ], null, RichBlockParagraph::class);
+
+        assertSame('paragraph', $paragraph->getType());
+        assertSame('hello', $paragraph->text);
+    }
+}
diff --git a/tests/Type/RichBlockPhotoTest.php b/tests/Type/RichBlockPhotoTest.php
new file mode 100644
index 00000000..ef368a9c
--- /dev/null
+++ b/tests/Type/RichBlockPhotoTest.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\PhotoSize;
+use Phptg\BotApi\Type\RichBlockPhoto;
+use Phptg\BotApi\Type\RichBlockCaption;
+
+use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class RichBlockPhotoTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $photo = new PhotoSize('f123', 'fullF123', 640, 480);
+        $block = new RichBlockPhoto([$photo]);
+
+        assertSame('photo', $block->getType());
+        assertCount(1, $block->photo);
+        assertNull($block->hasSpoiler);
+        assertNull($block->caption);
+    }
+
+    public function testFull(): void
+    {
+        $photo = new PhotoSize('f123', 'fullF123', 640, 480);
+        $caption = new RichBlockCaption('photo');
+        $block = new RichBlockPhoto([$photo], true, $caption);
+
+        assertSame('photo', $block->getType());
+        assertTrue($block->hasSpoiler);
+        assertSame($caption, $block->caption);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'photo',
+            'photo' => [
+                ['file_id' => 'f123', 'file_unique_id' => 'fullF123', 'width' => 640, 'height' => 480],
+                ['file_id' => 'f456', 'file_unique_id' => 'fullF456', 'width' => 320, 'height' => 240],
+            ],
+        ], null, RichBlockPhoto::class);
+
+        assertSame('photo', $block->getType());
+        assertCount(2, $block->photo);
+        assertInstanceOf(PhotoSize::class, $block->photo[0]);
+        assertInstanceOf(PhotoSize::class, $block->photo[1]);
+        assertNull($block->hasSpoiler);
+        assertNull($block->caption);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'photo',
+            'photo' => [
+                ['file_id' => 'f123', 'file_unique_id' => 'fullF123', 'width' => 640, 'height' => 480],
+            ],
+            'has_spoiler' => true,
+            'caption' => ['text' => 'photo'],
+        ], null, RichBlockPhoto::class);
+
+        assertSame('photo', $block->getType());
+        assertCount(1, $block->photo);
+        assertTrue($block->hasSpoiler);
+        assertInstanceOf(RichBlockCaption::class, $block->caption);
+    }
+}
diff --git a/tests/Type/RichBlockPreformattedTest.php b/tests/Type/RichBlockPreformattedTest.php
new file mode 100644
index 00000000..01221ad2
--- /dev/null
+++ b/tests/Type/RichBlockPreformattedTest.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockPreformatted;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockPreformattedTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $pre = new RichBlockPreformatted('hello');
+
+        assertSame('pre', $pre->getType());
+        assertSame('hello', $pre->text);
+        assertNull($pre->language);
+    }
+
+    public function testFull(): void
+    {
+        $pre = new RichBlockPreformatted('hello', 'php');
+
+        assertSame('pre', $pre->getType());
+        assertSame('hello', $pre->text);
+        assertSame('php', $pre->language);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $pre = (new ObjectFactory())->create([
+            'type' => 'pre',
+            'text' => 'hello',
+        ], null, RichBlockPreformatted::class);
+
+        assertSame('pre', $pre->getType());
+        assertSame('hello', $pre->text);
+        assertNull($pre->language);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $pre = (new ObjectFactory())->create([
+            'type' => 'pre',
+            'text' => ['type' => 'bold', 'text' => 'hello'],
+            'language' => 'python',
+        ], null, RichBlockPreformatted::class);
+
+        assertSame('pre', $pre->getType());
+        assertInstanceOf(RichTextBold::class, $pre->text);
+        assertSame('hello', $pre->text->text);
+        assertSame('python', $pre->language);
+    }
+}
diff --git a/tests/Type/RichBlockPullQuotationTest.php b/tests/Type/RichBlockPullQuotationTest.php
new file mode 100644
index 00000000..8f6785bf
--- /dev/null
+++ b/tests/Type/RichBlockPullQuotationTest.php
@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockPullQuotation;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockPullQuotationTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $pullquote = new RichBlockPullQuotation('hello');
+
+        assertSame('pullquote', $pullquote->getType());
+        assertSame('hello', $pullquote->text);
+        assertNull($pullquote->credit);
+    }
+
+    public function testFull(): void
+    {
+        $pullquote = new RichBlockPullQuotation('hello', 'credit');
+
+        assertSame('pullquote', $pullquote->getType());
+        assertSame('hello', $pullquote->text);
+        assertSame('credit', $pullquote->credit);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $pullquote = (new ObjectFactory())->create([
+            'type' => 'pullquote',
+            'text' => 'hello',
+        ], null, RichBlockPullQuotation::class);
+
+        assertSame('pullquote', $pullquote->getType());
+        assertSame('hello', $pullquote->text);
+        assertNull($pullquote->credit);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $pullquote = (new ObjectFactory())->create([
+            'type' => 'pullquote',
+            'text' => ['type' => 'bold', 'text' => 'hello'],
+            'credit' => ['type' => 'bold', 'text' => 'author'],
+        ], null, RichBlockPullQuotation::class);
+
+        assertSame('pullquote', $pullquote->getType());
+        assertInstanceOf(RichTextBold::class, $pullquote->text);
+        assertSame('hello', $pullquote->text->text);
+        assertInstanceOf(RichTextBold::class, $pullquote->credit);
+        assertSame('author', $pullquote->credit->text);
+    }
+}
diff --git a/tests/Type/RichBlockSectionHeadingTest.php b/tests/Type/RichBlockSectionHeadingTest.php
new file mode 100644
index 00000000..47dca1f6
--- /dev/null
+++ b/tests/Type/RichBlockSectionHeadingTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockSectionHeading;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockSectionHeadingTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $heading = new RichBlockSectionHeading('hello', 1);
+
+        assertSame('heading', $heading->getType());
+        assertSame('hello', $heading->text);
+        assertSame(1, $heading->size);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $heading = (new ObjectFactory())->create([
+            'type' => 'heading',
+            'text' => 'hello',
+            'size' => 2,
+        ], null, RichBlockSectionHeading::class);
+
+        assertSame('heading', $heading->getType());
+        assertSame('hello', $heading->text);
+        assertSame(2, $heading->size);
+    }
+}
diff --git a/tests/Type/RichBlockSlideshowTest.php b/tests/Type/RichBlockSlideshowTest.php
new file mode 100644
index 00000000..b1119d6f
--- /dev/null
+++ b/tests/Type/RichBlockSlideshowTest.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockSlideshow;
+use Phptg\BotApi\Type\RichBlockParagraph;
+use Phptg\BotApi\Type\RichBlockCaption;
+
+use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockSlideshowTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $slideshow = new RichBlockSlideshow([new RichBlockParagraph('hello')]);
+
+        assertSame('slideshow', $slideshow->getType());
+        assertCount(1, $slideshow->blocks);
+        assertNull($slideshow->caption);
+    }
+
+    public function testFull(): void
+    {
+        $caption = new RichBlockCaption('caption text');
+        $slideshow = new RichBlockSlideshow([new RichBlockParagraph('hello')], $caption);
+
+        assertSame('slideshow', $slideshow->getType());
+        assertCount(1, $slideshow->blocks);
+        assertSame($caption, $slideshow->caption);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $slideshow = (new ObjectFactory())->create([
+            'type' => 'slideshow',
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+        ], null, RichBlockSlideshow::class);
+
+        assertSame('slideshow', $slideshow->getType());
+        assertCount(1, $slideshow->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $slideshow->blocks[0]);
+        assertNull($slideshow->caption);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $slideshow = (new ObjectFactory())->create([
+            'type' => 'slideshow',
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+            'caption' => ['text' => 'caption text'],
+        ], null, RichBlockSlideshow::class);
+
+        assertSame('slideshow', $slideshow->getType());
+        assertCount(1, $slideshow->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $slideshow->blocks[0]);
+        assertInstanceOf(RichBlockCaption::class, $slideshow->caption);
+    }
+}
diff --git a/tests/Type/RichBlockTableCellTest.php b/tests/Type/RichBlockTableCellTest.php
new file mode 100644
index 00000000..061e018e
--- /dev/null
+++ b/tests/Type/RichBlockTableCellTest.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockTableCell;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class RichBlockTableCellTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $cell = new RichBlockTableCell('left', 'top');
+
+        assertSame('left', $cell->align);
+        assertSame('top', $cell->valign);
+        assertNull($cell->text);
+        assertNull($cell->isHeader);
+        assertNull($cell->colspan);
+        assertNull($cell->rowspan);
+    }
+
+    public function testFull(): void
+    {
+        $cell = new RichBlockTableCell('center', 'middle', 'hello', true, 2, 3);
+
+        assertSame('center', $cell->align);
+        assertSame('middle', $cell->valign);
+        assertSame('hello', $cell->text);
+        assertTrue($cell->isHeader);
+        assertSame(2, $cell->colspan);
+        assertSame(3, $cell->rowspan);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $cell = (new ObjectFactory())->create([
+            'align' => 'left',
+            'valign' => 'top',
+        ], null, RichBlockTableCell::class);
+
+        assertSame('left', $cell->align);
+        assertSame('top', $cell->valign);
+        assertNull($cell->text);
+        assertNull($cell->isHeader);
+        assertNull($cell->colspan);
+        assertNull($cell->rowspan);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $cell = (new ObjectFactory())->create([
+            'align' => 'center',
+            'valign' => 'middle',
+            'text' => ['type' => 'bold', 'text' => 'hello'],
+            'is_header' => true,
+            'colspan' => 2,
+            'rowspan' => 3,
+        ], null, RichBlockTableCell::class);
+
+        assertSame('center', $cell->align);
+        assertSame('middle', $cell->valign);
+        assertInstanceOf(RichTextBold::class, $cell->text);
+        assertSame('hello', $cell->text->text);
+        assertTrue($cell->isHeader);
+        assertSame(2, $cell->colspan);
+        assertSame(3, $cell->rowspan);
+    }
+}
diff --git a/tests/Type/RichBlockTableTest.php b/tests/Type/RichBlockTableTest.php
new file mode 100644
index 00000000..5095041a
--- /dev/null
+++ b/tests/Type/RichBlockTableTest.php
@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockTable;
+use Phptg\BotApi\Type\RichBlockTableCell;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class RichBlockTableTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $cell = new RichBlockTableCell('left', 'top');
+        $table = new RichBlockTable([[$cell]]);
+
+        assertSame('table', $table->getType());
+        assertCount(1, $table->cells);
+        assertCount(1, $table->cells[0]);
+        assertSame('left', $table->cells[0][0]->align);
+        assertSame('top', $table->cells[0][0]->valign);
+        assertNull($table->isBordered);
+        assertNull($table->isStriped);
+        assertNull($table->caption);
+    }
+
+    public function testFull(): void
+    {
+        $cell = new RichBlockTableCell('center', 'middle');
+        $table = new RichBlockTable([[$cell]], true, true, 'caption');
+
+        assertSame('table', $table->getType());
+        assertCount(1, $table->cells);
+        assertCount(1, $table->cells[0]);
+        assertSame('center', $table->cells[0][0]->align);
+        assertSame('middle', $table->cells[0][0]->valign);
+        assertTrue($table->isBordered);
+        assertTrue($table->isStriped);
+        assertSame('caption', $table->caption);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $table = (new ObjectFactory())->create([
+            'type' => 'table',
+            'cells' => [
+                [
+                    ['align' => 'left', 'valign' => 'top'],
+                ],
+            ],
+        ], null, RichBlockTable::class);
+
+        assertSame('table', $table->getType());
+        assertCount(1, $table->cells);
+        assertCount(1, $table->cells[0]);
+        assertInstanceOf(RichBlockTableCell::class, $table->cells[0][0]);
+        assertSame('left', $table->cells[0][0]->align);
+        assertSame('top', $table->cells[0][0]->valign);
+        assertNull($table->isBordered);
+        assertNull($table->isStriped);
+        assertNull($table->caption);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $table = (new ObjectFactory())->create([
+            'type' => 'table',
+            'cells' => [
+                [
+                    ['align' => 'center', 'valign' => 'middle'],
+                ],
+            ],
+            'is_bordered' => true,
+            'is_striped' => true,
+            'caption' => ['type' => 'bold', 'text' => 'caption'],
+        ], null, RichBlockTable::class);
+
+        assertSame('table', $table->getType());
+        assertCount(1, $table->cells);
+        assertCount(1, $table->cells[0]);
+        assertInstanceOf(RichBlockTableCell::class, $table->cells[0][0]);
+        assertSame('center', $table->cells[0][0]->align);
+        assertSame('middle', $table->cells[0][0]->valign);
+        assertTrue($table->isBordered);
+        assertTrue($table->isStriped);
+        assertInstanceOf(RichTextBold::class, $table->caption);
+        assertSame('caption', $table->caption->text);
+    }
+}
diff --git a/tests/Type/RichBlockThinkingTest.php b/tests/Type/RichBlockThinkingTest.php
new file mode 100644
index 00000000..6ba41f10
--- /dev/null
+++ b/tests/Type/RichBlockThinkingTest.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockThinking;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockThinkingTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $thinking = new RichBlockThinking('thinking...');
+
+        assertSame('thinking', $thinking->getType());
+        assertSame('thinking...', $thinking->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $thinking = (new ObjectFactory())->create([
+            'type' => 'thinking',
+            'text' => 'thinking...',
+        ], null, RichBlockThinking::class);
+
+        assertSame('thinking', $thinking->getType());
+        assertSame('thinking...', $thinking->text);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $thinking = (new ObjectFactory())->create([
+            'type' => 'thinking',
+            'text' => ['type' => 'bold', 'text' => 'thinking...'],
+        ], null, RichBlockThinking::class);
+
+        assertSame('thinking', $thinking->getType());
+        assertInstanceOf(RichTextBold::class, $thinking->text);
+        assertSame('thinking...', $thinking->text->text);
+    }
+}
diff --git a/tests/Type/RichBlockVideoTest.php b/tests/Type/RichBlockVideoTest.php
new file mode 100644
index 00000000..be4d7a26
--- /dev/null
+++ b/tests/Type/RichBlockVideoTest.php
@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\Video;
+use Phptg\BotApi\Type\RichBlockVideo;
+use Phptg\BotApi\Type\RichBlockCaption;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+use function PHPUnit\Framework\assertTrue;
+
+final class RichBlockVideoTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $video = new Video('f123', 'fullF123', 640, 480, 60);
+        $block = new RichBlockVideo($video);
+
+        assertSame('video', $block->getType());
+        assertSame($video, $block->video);
+        assertNull($block->hasSpoiler);
+        assertNull($block->caption);
+    }
+
+    public function testFull(): void
+    {
+        $video = new Video('f123', 'fullF123', 640, 480, 60);
+        $caption = new RichBlockCaption('video');
+        $block = new RichBlockVideo($video, true, $caption);
+
+        assertSame('video', $block->getType());
+        assertTrue($block->hasSpoiler);
+        assertSame($caption, $block->caption);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'video',
+            'video' => [
+                'file_id' => 'f123',
+                'file_unique_id' => 'fullF123',
+                'width' => 640,
+                'height' => 480,
+                'duration' => 60,
+            ],
+        ], null, RichBlockVideo::class);
+
+        assertSame('video', $block->getType());
+        assertInstanceOf(Video::class, $block->video);
+        assertNull($block->hasSpoiler);
+        assertNull($block->caption);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'video',
+            'video' => [
+                'file_id' => 'f123',
+                'file_unique_id' => 'fullF123',
+                'width' => 640,
+                'height' => 480,
+                'duration' => 60,
+            ],
+            'has_spoiler' => true,
+            'caption' => ['text' => 'video'],
+        ], null, RichBlockVideo::class);
+
+        assertSame('video', $block->getType());
+        assertInstanceOf(Video::class, $block->video);
+        assertTrue($block->hasSpoiler);
+        assertInstanceOf(RichBlockCaption::class, $block->caption);
+    }
+}
diff --git a/tests/Type/RichBlockVoiceNoteTest.php b/tests/Type/RichBlockVoiceNoteTest.php
new file mode 100644
index 00000000..21651ce2
--- /dev/null
+++ b/tests/Type/RichBlockVoiceNoteTest.php
@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\Voice;
+use Phptg\BotApi\Type\RichBlockVoiceNote;
+use Phptg\BotApi\Type\RichBlockCaption;
+
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertSame;
+
+final class RichBlockVoiceNoteTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $voice = new Voice('f123', 'fullF123', 60);
+        $block = new RichBlockVoiceNote($voice);
+
+        assertSame('voice_note', $block->getType());
+        assertSame($voice, $block->voiceNote);
+        assertNull($block->caption);
+    }
+
+    public function testFull(): void
+    {
+        $voice = new Voice('f123', 'fullF123', 60);
+        $caption = new RichBlockCaption('voice note');
+        $block = new RichBlockVoiceNote($voice, $caption);
+
+        assertSame('voice_note', $block->getType());
+        assertSame($caption, $block->caption);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'voice_note',
+            'voice_note' => [
+                'file_id' => 'f123',
+                'file_unique_id' => 'fullF123',
+                'duration' => 60,
+            ],
+        ], null, RichBlockVoiceNote::class);
+
+        assertSame('voice_note', $block->getType());
+        assertInstanceOf(Voice::class, $block->voiceNote);
+        assertNull($block->caption);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $block = (new ObjectFactory())->create([
+            'type' => 'voice_note',
+            'voice_note' => [
+                'file_id' => 'f123',
+                'file_unique_id' => 'fullF123',
+                'duration' => 60,
+            ],
+            'caption' => ['text' => 'voice note'],
+        ], null, RichBlockVoiceNote::class);
+
+        assertSame('voice_note', $block->getType());
+        assertInstanceOf(Voice::class, $block->voiceNote);
+        assertInstanceOf(RichBlockCaption::class, $block->caption);
+    }
+}
diff --git a/tests/Type/RichMessageTest.php b/tests/Type/RichMessageTest.php
new file mode 100644
index 00000000..203405c8
--- /dev/null
+++ b/tests/Type/RichMessageTest.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichBlockParagraph;
+use Phptg\BotApi\Type\RichMessage;
+
+use function PHPUnit\Framework\assertCount;
+use function PHPUnit\Framework\assertInstanceOf;
+use function PHPUnit\Framework\assertNull;
+use function PHPUnit\Framework\assertTrue;
+
+final class RichMessageTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $message = new RichMessage([new RichBlockParagraph('hello')]);
+
+        assertCount(1, $message->blocks);
+        assertNull($message->isRtl);
+    }
+
+    public function testFull(): void
+    {
+        $message = new RichMessage([new RichBlockParagraph('hello')], true);
+
+        assertCount(1, $message->blocks);
+        assertTrue($message->isRtl);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $message = (new ObjectFactory())->create([
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+        ], null, RichMessage::class);
+
+        assertCount(1, $message->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $message->blocks[0]);
+        assertNull($message->isRtl);
+    }
+
+    public function testFromTelegramResultFull(): void
+    {
+        $message = (new ObjectFactory())->create([
+            'blocks' => [
+                ['type' => 'paragraph', 'text' => 'hello'],
+            ],
+            'is_rtl' => true,
+        ], null, RichMessage::class);
+
+        assertCount(1, $message->blocks);
+        assertInstanceOf(RichBlockParagraph::class, $message->blocks[0]);
+        assertTrue($message->isRtl);
+    }
+}
diff --git a/tests/Type/RichTextAnchorLinkTest.php b/tests/Type/RichTextAnchorLinkTest.php
new file mode 100644
index 00000000..d367f859
--- /dev/null
+++ b/tests/Type/RichTextAnchorLinkTest.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextAnchorLink;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextAnchorLinkTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $anchorLink = new RichTextAnchorLink('hello', 'section1');
+
+        assertSame('anchor_link', $anchorLink->getType());
+        assertSame('hello', $anchorLink->text);
+        assertSame('section1', $anchorLink->anchorName);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $anchorLink = (new ObjectFactory())->create([
+            'type' => 'anchor_link',
+            'text' => 'hello',
+            'anchor_name' => 'section1',
+        ], null, RichTextAnchorLink::class);
+
+        assertSame('anchor_link', $anchorLink->getType());
+        assertSame('hello', $anchorLink->text);
+        assertSame('section1', $anchorLink->anchorName);
+    }
+
+    public function testEmptyAnchorName(): void
+    {
+        $anchorLink = (new ObjectFactory())->create([
+            'type' => 'anchor_link',
+            'text' => 'back to top',
+            'anchor_name' => '',
+        ], null, RichTextAnchorLink::class);
+
+        assertSame('', $anchorLink->anchorName);
+    }
+}
diff --git a/tests/Type/RichTextAnchorTest.php b/tests/Type/RichTextAnchorTest.php
new file mode 100644
index 00000000..120bd834
--- /dev/null
+++ b/tests/Type/RichTextAnchorTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextAnchor;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextAnchorTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $anchor = new RichTextAnchor('section1');
+
+        assertSame('anchor', $anchor->getType());
+        assertSame('section1', $anchor->name);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $anchor = (new ObjectFactory())->create([
+            'type' => 'anchor',
+            'name' => 'section1',
+        ], null, RichTextAnchor::class);
+
+        assertSame('anchor', $anchor->getType());
+        assertSame('section1', $anchor->name);
+    }
+}
diff --git a/tests/Type/RichTextBankCardNumberTest.php b/tests/Type/RichTextBankCardNumberTest.php
new file mode 100644
index 00000000..b04483b7
--- /dev/null
+++ b/tests/Type/RichTextBankCardNumberTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextBankCardNumber;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextBankCardNumberTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $bankCardNumber = new RichTextBankCardNumber('hello', '4111111111111111');
+
+        assertSame('bank_card_number', $bankCardNumber->getType());
+        assertSame('hello', $bankCardNumber->text);
+        assertSame('4111111111111111', $bankCardNumber->bankCardNumber);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $bankCardNumber = (new ObjectFactory())->create([
+            'type' => 'bank_card_number',
+            'text' => 'hello',
+            'bank_card_number' => '4111111111111111',
+        ], null, RichTextBankCardNumber::class);
+
+        assertSame('bank_card_number', $bankCardNumber->getType());
+        assertSame('hello', $bankCardNumber->text);
+        assertSame('4111111111111111', $bankCardNumber->bankCardNumber);
+    }
+}
diff --git a/tests/Type/RichTextBoldTest.php b/tests/Type/RichTextBoldTest.php
new file mode 100644
index 00000000..4456a276
--- /dev/null
+++ b/tests/Type/RichTextBoldTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextBold;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextBoldTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $bold = new RichTextBold('hello');
+
+        assertSame('bold', $bold->getType());
+        assertSame('hello', $bold->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $bold = (new ObjectFactory())->create([
+            'type' => 'bold',
+            'text' => 'hello',
+        ], null, RichTextBold::class);
+
+        assertSame('bold', $bold->getType());
+        assertSame('hello', $bold->text);
+    }
+}
diff --git a/tests/Type/RichTextBotCommandTest.php b/tests/Type/RichTextBotCommandTest.php
new file mode 100644
index 00000000..683703b3
--- /dev/null
+++ b/tests/Type/RichTextBotCommandTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextBotCommand;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextBotCommandTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $botCommand = new RichTextBotCommand('hello', '/start');
+
+        assertSame('bot_command', $botCommand->getType());
+        assertSame('hello', $botCommand->text);
+        assertSame('/start', $botCommand->botCommand);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $botCommand = (new ObjectFactory())->create([
+            'type' => 'bot_command',
+            'text' => 'hello',
+            'bot_command' => '/start',
+        ], null, RichTextBotCommand::class);
+
+        assertSame('bot_command', $botCommand->getType());
+        assertSame('hello', $botCommand->text);
+        assertSame('/start', $botCommand->botCommand);
+    }
+}
diff --git a/tests/Type/RichTextCashtagTest.php b/tests/Type/RichTextCashtagTest.php
new file mode 100644
index 00000000..661e830d
--- /dev/null
+++ b/tests/Type/RichTextCashtagTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextCashtag;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextCashtagTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $cashtag = new RichTextCashtag('hello', '$AAPL');
+
+        assertSame('cashtag', $cashtag->getType());
+        assertSame('hello', $cashtag->text);
+        assertSame('$AAPL', $cashtag->cashtag);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $cashtag = (new ObjectFactory())->create([
+            'type' => 'cashtag',
+            'text' => 'hello',
+            'cashtag' => '$AAPL',
+        ], null, RichTextCashtag::class);
+
+        assertSame('cashtag', $cashtag->getType());
+        assertSame('hello', $cashtag->text);
+        assertSame('$AAPL', $cashtag->cashtag);
+    }
+}
diff --git a/tests/Type/RichTextCodeTest.php b/tests/Type/RichTextCodeTest.php
new file mode 100644
index 00000000..e75fe908
--- /dev/null
+++ b/tests/Type/RichTextCodeTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextCode;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextCodeTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $code = new RichTextCode('hello');
+
+        assertSame('code', $code->getType());
+        assertSame('hello', $code->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $code = (new ObjectFactory())->create([
+            'type' => 'code',
+            'text' => 'hello',
+        ], null, RichTextCode::class);
+
+        assertSame('code', $code->getType());
+        assertSame('hello', $code->text);
+    }
+}
diff --git a/tests/Type/RichTextCustomEmojiTest.php b/tests/Type/RichTextCustomEmojiTest.php
new file mode 100644
index 00000000..6e9466b4
--- /dev/null
+++ b/tests/Type/RichTextCustomEmojiTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextCustomEmoji;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextCustomEmojiTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $customEmoji = new RichTextCustomEmoji('emoji123', '😀');
+
+        assertSame('custom_emoji', $customEmoji->getType());
+        assertSame('emoji123', $customEmoji->customEmojiId);
+        assertSame('😀', $customEmoji->alternativeText);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $customEmoji = (new ObjectFactory())->create([
+            'type' => 'custom_emoji',
+            'custom_emoji_id' => 'emoji123',
+            'alternative_text' => '😀',
+        ], null, RichTextCustomEmoji::class);
+
+        assertSame('custom_emoji', $customEmoji->getType());
+        assertSame('emoji123', $customEmoji->customEmojiId);
+        assertSame('😀', $customEmoji->alternativeText);
+    }
+}
diff --git a/tests/Type/RichTextDateTimeTest.php b/tests/Type/RichTextDateTimeTest.php
new file mode 100644
index 00000000..f5f61747
--- /dev/null
+++ b/tests/Type/RichTextDateTimeTest.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextDateTime;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextDateTimeTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $dateTime = new RichTextDateTime('hello', 1749600000, 'Y-m-d H:i:s');
+
+        assertSame('date_time', $dateTime->getType());
+        assertSame('hello', $dateTime->text);
+        assertSame(1749600000, $dateTime->unixTime);
+        assertSame('Y-m-d H:i:s', $dateTime->dateTimeFormat);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $dateTime = (new ObjectFactory())->create([
+            'type' => 'date_time',
+            'text' => 'hello',
+            'unix_time' => 1749600000,
+            'date_time_format' => 'Y-m-d H:i:s',
+        ], null, RichTextDateTime::class);
+
+        assertSame('date_time', $dateTime->getType());
+        assertSame('hello', $dateTime->text);
+        assertSame(1749600000, $dateTime->unixTime);
+        assertSame('Y-m-d H:i:s', $dateTime->dateTimeFormat);
+    }
+}
diff --git a/tests/Type/RichTextEmailAddressTest.php b/tests/Type/RichTextEmailAddressTest.php
new file mode 100644
index 00000000..a71dc3fb
--- /dev/null
+++ b/tests/Type/RichTextEmailAddressTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextEmailAddress;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextEmailAddressTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $emailAddress = new RichTextEmailAddress('hello', 'test@example.com');
+
+        assertSame('email_address', $emailAddress->getType());
+        assertSame('hello', $emailAddress->text);
+        assertSame('test@example.com', $emailAddress->emailAddress);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $emailAddress = (new ObjectFactory())->create([
+            'type' => 'email_address',
+            'text' => 'hello',
+            'email_address' => 'test@example.com',
+        ], null, RichTextEmailAddress::class);
+
+        assertSame('email_address', $emailAddress->getType());
+        assertSame('hello', $emailAddress->text);
+        assertSame('test@example.com', $emailAddress->emailAddress);
+    }
+}
diff --git a/tests/Type/RichTextHashtagTest.php b/tests/Type/RichTextHashtagTest.php
new file mode 100644
index 00000000..fbb174d5
--- /dev/null
+++ b/tests/Type/RichTextHashtagTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextHashtag;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextHashtagTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $hashtag = new RichTextHashtag('hello', '#world');
+
+        assertSame('hashtag', $hashtag->getType());
+        assertSame('hello', $hashtag->text);
+        assertSame('#world', $hashtag->hashtag);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $hashtag = (new ObjectFactory())->create([
+            'type' => 'hashtag',
+            'text' => 'hello',
+            'hashtag' => '#world',
+        ], null, RichTextHashtag::class);
+
+        assertSame('hashtag', $hashtag->getType());
+        assertSame('hello', $hashtag->text);
+        assertSame('#world', $hashtag->hashtag);
+    }
+}
diff --git a/tests/Type/RichTextItalicTest.php b/tests/Type/RichTextItalicTest.php
new file mode 100644
index 00000000..e6d0a4d3
--- /dev/null
+++ b/tests/Type/RichTextItalicTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextItalic;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextItalicTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $italic = new RichTextItalic('hello');
+
+        assertSame('italic', $italic->getType());
+        assertSame('hello', $italic->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $italic = (new ObjectFactory())->create([
+            'type' => 'italic',
+            'text' => 'hello',
+        ], null, RichTextItalic::class);
+
+        assertSame('italic', $italic->getType());
+        assertSame('hello', $italic->text);
+    }
+}
diff --git a/tests/Type/RichTextMarkedTest.php b/tests/Type/RichTextMarkedTest.php
new file mode 100644
index 00000000..20855669
--- /dev/null
+++ b/tests/Type/RichTextMarkedTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextMarked;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextMarkedTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $marked = new RichTextMarked('hello');
+
+        assertSame('marked', $marked->getType());
+        assertSame('hello', $marked->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $marked = (new ObjectFactory())->create([
+            'type' => 'marked',
+            'text' => 'hello',
+        ], null, RichTextMarked::class);
+
+        assertSame('marked', $marked->getType());
+        assertSame('hello', $marked->text);
+    }
+}
diff --git a/tests/Type/RichTextMathematicalExpressionTest.php b/tests/Type/RichTextMathematicalExpressionTest.php
new file mode 100644
index 00000000..d451ef2c
--- /dev/null
+++ b/tests/Type/RichTextMathematicalExpressionTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextMathematicalExpression;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextMathematicalExpressionTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $expression = new RichTextMathematicalExpression('E = mc^2');
+
+        assertSame('mathematical_expression', $expression->getType());
+        assertSame('E = mc^2', $expression->expression);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $expression = (new ObjectFactory())->create([
+            'type' => 'mathematical_expression',
+            'expression' => 'E = mc^2',
+        ], null, RichTextMathematicalExpression::class);
+
+        assertSame('mathematical_expression', $expression->getType());
+        assertSame('E = mc^2', $expression->expression);
+    }
+}
diff --git a/tests/Type/RichTextMentionTest.php b/tests/Type/RichTextMentionTest.php
new file mode 100644
index 00000000..1f37853f
--- /dev/null
+++ b/tests/Type/RichTextMentionTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextMention;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextMentionTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $mention = new RichTextMention('hello', 'johndoe');
+
+        assertSame('mention', $mention->getType());
+        assertSame('hello', $mention->text);
+        assertSame('johndoe', $mention->username);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $mention = (new ObjectFactory())->create([
+            'type' => 'mention',
+            'text' => 'hello',
+            'username' => 'johndoe',
+        ], null, RichTextMention::class);
+
+        assertSame('mention', $mention->getType());
+        assertSame('hello', $mention->text);
+        assertSame('johndoe', $mention->username);
+    }
+}
diff --git a/tests/Type/RichTextPhoneNumberTest.php b/tests/Type/RichTextPhoneNumberTest.php
new file mode 100644
index 00000000..68860ff2
--- /dev/null
+++ b/tests/Type/RichTextPhoneNumberTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextPhoneNumber;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextPhoneNumberTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $phoneNumber = new RichTextPhoneNumber('hello', '+1234567890');
+
+        assertSame('phone_number', $phoneNumber->getType());
+        assertSame('hello', $phoneNumber->text);
+        assertSame('+1234567890', $phoneNumber->phoneNumber);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $phoneNumber = (new ObjectFactory())->create([
+            'type' => 'phone_number',
+            'text' => 'hello',
+            'phone_number' => '+1234567890',
+        ], null, RichTextPhoneNumber::class);
+
+        assertSame('phone_number', $phoneNumber->getType());
+        assertSame('hello', $phoneNumber->text);
+        assertSame('+1234567890', $phoneNumber->phoneNumber);
+    }
+}
diff --git a/tests/Type/RichTextReferenceLinkTest.php b/tests/Type/RichTextReferenceLinkTest.php
new file mode 100644
index 00000000..1bc660d1
--- /dev/null
+++ b/tests/Type/RichTextReferenceLinkTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextReferenceLink;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextReferenceLinkTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $referenceLink = new RichTextReferenceLink('hello', 'ref1');
+
+        assertSame('reference_link', $referenceLink->getType());
+        assertSame('hello', $referenceLink->text);
+        assertSame('ref1', $referenceLink->referenceName);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $referenceLink = (new ObjectFactory())->create([
+            'type' => 'reference_link',
+            'text' => 'hello',
+            'reference_name' => 'ref1',
+        ], null, RichTextReferenceLink::class);
+
+        assertSame('reference_link', $referenceLink->getType());
+        assertSame('hello', $referenceLink->text);
+        assertSame('ref1', $referenceLink->referenceName);
+    }
+}
diff --git a/tests/Type/RichTextReferenceTest.php b/tests/Type/RichTextReferenceTest.php
new file mode 100644
index 00000000..7000dbe1
--- /dev/null
+++ b/tests/Type/RichTextReferenceTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextReference;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextReferenceTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $reference = new RichTextReference('hello', 'ref1');
+
+        assertSame('reference', $reference->getType());
+        assertSame('hello', $reference->text);
+        assertSame('ref1', $reference->name);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $reference = (new ObjectFactory())->create([
+            'type' => 'reference',
+            'text' => 'hello',
+            'name' => 'ref1',
+        ], null, RichTextReference::class);
+
+        assertSame('reference', $reference->getType());
+        assertSame('hello', $reference->text);
+        assertSame('ref1', $reference->name);
+    }
+}
diff --git a/tests/Type/RichTextSpoilerTest.php b/tests/Type/RichTextSpoilerTest.php
new file mode 100644
index 00000000..045a1925
--- /dev/null
+++ b/tests/Type/RichTextSpoilerTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextSpoiler;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextSpoilerTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $spoiler = new RichTextSpoiler('hello');
+
+        assertSame('spoiler', $spoiler->getType());
+        assertSame('hello', $spoiler->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $spoiler = (new ObjectFactory())->create([
+            'type' => 'spoiler',
+            'text' => 'hello',
+        ], null, RichTextSpoiler::class);
+
+        assertSame('spoiler', $spoiler->getType());
+        assertSame('hello', $spoiler->text);
+    }
+}
diff --git a/tests/Type/RichTextStrikethroughTest.php b/tests/Type/RichTextStrikethroughTest.php
new file mode 100644
index 00000000..3858f2e7
--- /dev/null
+++ b/tests/Type/RichTextStrikethroughTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextStrikethrough;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextStrikethroughTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $strikethrough = new RichTextStrikethrough('hello');
+
+        assertSame('strikethrough', $strikethrough->getType());
+        assertSame('hello', $strikethrough->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $strikethrough = (new ObjectFactory())->create([
+            'type' => 'strikethrough',
+            'text' => 'hello',
+        ], null, RichTextStrikethrough::class);
+
+        assertSame('strikethrough', $strikethrough->getType());
+        assertSame('hello', $strikethrough->text);
+    }
+}
diff --git a/tests/Type/RichTextSubscriptTest.php b/tests/Type/RichTextSubscriptTest.php
new file mode 100644
index 00000000..2ae2cab3
--- /dev/null
+++ b/tests/Type/RichTextSubscriptTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextSubscript;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextSubscriptTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $subscript = new RichTextSubscript('hello');
+
+        assertSame('subscript', $subscript->getType());
+        assertSame('hello', $subscript->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $subscript = (new ObjectFactory())->create([
+            'type' => 'subscript',
+            'text' => 'hello',
+        ], null, RichTextSubscript::class);
+
+        assertSame('subscript', $subscript->getType());
+        assertSame('hello', $subscript->text);
+    }
+}
diff --git a/tests/Type/RichTextSuperscriptTest.php b/tests/Type/RichTextSuperscriptTest.php
new file mode 100644
index 00000000..ffe2bf3e
--- /dev/null
+++ b/tests/Type/RichTextSuperscriptTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextSuperscript;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextSuperscriptTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $superscript = new RichTextSuperscript('hello');
+
+        assertSame('superscript', $superscript->getType());
+        assertSame('hello', $superscript->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $superscript = (new ObjectFactory())->create([
+            'type' => 'superscript',
+            'text' => 'hello',
+        ], null, RichTextSuperscript::class);
+
+        assertSame('superscript', $superscript->getType());
+        assertSame('hello', $superscript->text);
+    }
+}
diff --git a/tests/Type/RichTextTextMentionTest.php b/tests/Type/RichTextTextMentionTest.php
new file mode 100644
index 00000000..c9e1c2aa
--- /dev/null
+++ b/tests/Type/RichTextTextMentionTest.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextTextMention;
+use Phptg\BotApi\Type\User;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextTextMentionTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $user = new User(123, false, 'John');
+        $textMention = new RichTextTextMention('hello', $user);
+
+        assertSame('text_mention', $textMention->getType());
+        assertSame('hello', $textMention->text);
+        assertSame($user, $textMention->user);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $textMention = (new ObjectFactory())->create([
+            'type' => 'text_mention',
+            'text' => 'hello',
+            'user' => ['id' => 123, 'is_bot' => false, 'first_name' => 'John'],
+        ], null, RichTextTextMention::class);
+
+        assertSame('text_mention', $textMention->getType());
+        assertSame('hello', $textMention->text);
+        assertSame(123, $textMention->user->id);
+        assertSame('John', $textMention->user->firstName);
+    }
+}
diff --git a/tests/Type/RichTextUnderlineTest.php b/tests/Type/RichTextUnderlineTest.php
new file mode 100644
index 00000000..0b42f3d7
--- /dev/null
+++ b/tests/Type/RichTextUnderlineTest.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextUnderline;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextUnderlineTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $underline = new RichTextUnderline('hello');
+
+        assertSame('underline', $underline->getType());
+        assertSame('hello', $underline->text);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $underline = (new ObjectFactory())->create([
+            'type' => 'underline',
+            'text' => 'hello',
+        ], null, RichTextUnderline::class);
+
+        assertSame('underline', $underline->getType());
+        assertSame('hello', $underline->text);
+    }
+}
diff --git a/tests/Type/RichTextUrlTest.php b/tests/Type/RichTextUrlTest.php
new file mode 100644
index 00000000..37fadd16
--- /dev/null
+++ b/tests/Type/RichTextUrlTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phptg\BotApi\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Phptg\BotApi\ParseResult\ObjectFactory;
+use Phptg\BotApi\Type\RichTextUrl;
+
+use function PHPUnit\Framework\assertSame;
+
+final class RichTextUrlTest extends TestCase
+{
+    public function testBase(): void
+    {
+        $url = new RichTextUrl('hello', 'https://example.com');
+
+        assertSame('url', $url->getType());
+        assertSame('hello', $url->text);
+        assertSame('https://example.com', $url->url);
+    }
+
+    public function testFromTelegramResult(): void
+    {
+        $url = (new ObjectFactory())->create([
+            'type' => 'url',
+            'text' => 'hello',
+            'url' => 'https://example.com',
+        ], null, RichTextUrl::class);
+
+        assertSame('url', $url->getType());
+        assertSame('hello', $url->text);
+        assertSame('https://example.com', $url->url);
+    }
+}
diff --git a/tests/Type/UserTest.php b/tests/Type/UserTest.php
index 05a67ae7..791f7474 100644
--- a/tests/Type/UserTest.php
+++ b/tests/Type/UserTest.php
@@ -35,6 +35,7 @@ public function testBase(): void
         assertNull($user->hasTopicsEnabled);
         assertNull($user->allowsUsersToCreateTopics);
         assertNull($user->canManageBots);
+        assertNull($user->supportsJoinRequestQueries);
     }
 
     public function testToRequestArray(): void
@@ -57,6 +58,7 @@ public function testToRequestArray(): void
             true,
             true,
             true,
+            true,
         );
 
         assertSame(
@@ -78,6 +80,7 @@ public function testToRequestArray(): void
                 'has_topics_enabled' => true,
                 'allows_users_to_create_topics' => true,
                 'can_manage_bots' => true,
+                'supports_join_request_queries' => true,
             ],
             $user->toRequestArray(),
         );
@@ -103,6 +106,7 @@ public function testFromTelegramResult(): void
             'has_topics_enabled' => true,
             'allows_users_to_create_topics' => true,
             'can_manage_bots' => true,
+            'supports_join_request_queries' => true,
         ], null, User::class);
 
         assertInstanceOf(User::class, $user);
@@ -123,5 +127,6 @@ public function testFromTelegramResult(): void
         assertSame(true, $user->hasTopicsEnabled);
         assertSame(true, $user->allowsUsersToCreateTopics);
         assertSame(true, $user->canManageBots);
+        assertSame(true, $user->supportsJoinRequestQueries);
     }
 }