Add more Walkthrough sections

Author: rojvv

src/chat-members.md

@@ -0,0 +1,79 @@
+---
+title: Chat Members
+parent: /#walkthrough
+prev: /topics
+next: /invite-links-and-join-requests
+---
+
+Chat members are represented by {{ "ChatMember" |> t }} objects. Each object contains the member and their status in the chat.
+
+## Listing Members
+
+Use {{ "getChatMembers" |> m }} to list the members of a group, supergroup, or channel.
+
+```ts
+const members = await client.getChatMembers(chatId);
+
+for (const { member, status } of members) {
+  console.log(member.id, status);
+}
+```
+
+Use {{ "getChatMember" |> m }} to retrieve one member.
+
+```ts
+const member = await client.getChatMember(chatId, userId);
+```
+
+## Handling Membership Changes
+
+The `chatMember` update contains the previous and current state of a member.
+
+```ts
+client.on("chatMember", (ctx) => {
+  const { oldChatMember, newChatMember } = ctx.update.chatMember;
+  console.log(oldChatMember.status, newChatMember.status);
+});
+```
+
+Use the `myChatMember` update to handle changes to the current account's membership.
+
+## Restricting a Member
+
+Use {{ "setChatMemberRights" |> m }} to restrict a member of a supergroup.
+
+```ts
+await client.setChatMemberRights(chatId, userId, {
+  rights: {
+    canSendMessages: false,
+  },
+});
+```
+
+Set `until` to a future Unix timestamp in seconds to make the restriction temporary.
+
+## Promoting a Member
+
+Use {{ "promoteChatMember" |> m }} to grant administrator rights.
+
+```ts
+await client.promoteChatMember(chatId, userId, {
+  canDeleteMessages: true,
+  canManageTopics: true,
+});
+```
+
+## Removing a Member
+
+Ban a member to prevent them from rejoining. Unban them to allow them to join again.
+
+```ts
+await client.banChatMember(chatId, userId);
+await client.unbanChatMember(chatId, userId);
+```
+
+Use {{ "kickChatMember" |> m }} to remove a member without keeping them banned.
+
+```ts
+await client.kickChatMember(chatId, userId);
+```

src/chat-settings.md

@@ -0,0 +1,49 @@
+---
+title: Chat Settings
+parent: /#walkthrough
+prev: /invite-links-and-join-requests
+next: /secret-chats
+---
+
+Administrators can change a chat's details and behavior.
+
+## Changing the Title and Description
+
+Use {{ "setChatTitle" |> m }} and {{ "setChatDescription" |> m }} to update a group, supergroup, or channel.
+
+```ts
+await client.setChatTitle(chatId, "MTKruto Community");
+await client.setChatDescription(chatId, "A place to discuss MTKruto.");
+```
+
+Set the description to an empty string to remove it.
+
+## Changing the Photo
+
+```ts
+await client.setChatPhoto(chatId, "./community.jpg");
+```
+
+Use {{ "deleteChatPhoto" |> m }} to remove the current photo.
+
+```ts
+await client.deleteChatPhoto(chatId);
+```
+
+## Enabling Slow Mode
+
+User clients can use {{ "setSlowMode" |> m }} to limit how often members can send messages in a supergroup.
+
+```ts
+await client.setSlowMode(chatId, "30s");
+```
+
+See {{ "SlowModeDuration" |> t }} for the available durations. Use {{ "disableSlowMode" |> m }} to turn slow mode off.
+
+## Automatically Deleting Messages
+
+User clients can use {{ "setMessageTtl" |> m }} to automatically delete messages after a number of seconds.
+
+```ts
+await client.setMessageTtl(chatId, 7 * 24 * 60 * 60);
+```

src/checklists.md

@@ -0,0 +1,69 @@
+---
+title: Checklists
+parent: /#walkthrough
+prev: /polls
+next: /scheduled-messages
+---
+
+Checklists let users track tasks in a chat. Use {{ "sendChecklist" |> m }} with a title and an array of {{ "InputChecklistItem" |> t }} objects.
+
+## Sending a Checklist
+
+```ts
+const message = await client.sendChecklist(chatId, "Release checklist", [
+  { text: "Run the tests" },
+  { text: "Update the documentation" },
+  { text: "Publish the release" },
+]);
+```
+
+Within an update handler, use `ctx.replyChecklist` to send a checklist to the current chat.
+
+## Letting Others Update a Checklist
+
+By default, only the creator can add or complete items. Set `isExtendableByOthers` and `isCompletableByOthers` to let other users do so.
+
+```ts
+await client.sendChecklist(chatId, "Trip planning", [
+  { text: "Book accommodation" },
+  { text: "Choose activities" },
+], {
+  isExtendableByOthers: true,
+  isCompletableByOthers: true,
+});
+```
+
+## Reading a Checklist
+
+Checklist messages contain their title, items, and permissions in `message.checklist`.
+
+```ts
+client.on("message:checklist", (ctx) => {
+  console.log(ctx.msg.checklist.title);
+
+  for (const item of ctx.msg.checklist.items) {
+    console.log(item.id, item.text, item.type);
+  }
+});
+```
+
+An item's `type` is either `"checked"` or `"unchecked"`. Checked items also include the user who completed them and the completion time.
+
+## Updating a Checklist
+
+User clients can check and uncheck items by their identifiers.
+
+```ts
+const itemId = message.checklist.items[0].id;
+
+await client.checkChecklistItem(chatId, message.id, itemId);
+await client.uncheckChecklistItem(chatId, message.id, itemId);
+```
+
+Use {{ "checkChecklistItems" |> m }} and {{ "uncheckChecklistItems" |> m }} to update multiple items. Use {{ "addToChecklist" |> m }} to append items.
+
+```ts
+await client.addToChecklist(chatId, message.id, [
+  { text: "Announce the release" },
+]);
+```

src/index.md

@@ -35,6 +35,15 @@ Its key features include:
 10. [Files](/files) {{ "/files" |> i }}
 11. [Inline Queries](/inline-queries) {{ "/inline-queries" |> i }}
 12. [Rich Messages and Text Formatting](/rich-messages-and-text-formatting) {{ "/rich-messages-and-text-formatting" |> i }}
+13. [Polls](/polls) {{ "/polls" |> i }}
+14. [Checklists](/checklists) {{ "/checklists" |> i }}
+15. [Scheduled Messages](/scheduled-messages) {{ "/scheduled-messages" |> i }}
+16. [Stories](/stories) {{ "/stories" |> i }}
+17. [Topics](/topics) {{ "/topics" |> i }}
+18. [Chat Members](/chat-members) {{ "/chat-members" |> i }}
+19. [Invite Links and Join Requests](/invite-links-and-join-requests) {{ "/invite-links-and-join-requests" |> i }}
+20. [Chat Settings](/chat-settings) {{ "/chat-settings" |> i }}
+21. [Secret Chats](/secret-chats) {{ "/secret-chats" |> i }}
 
 ### Guides
 

src/invite-links-and-join-requests.md

@@ -0,0 +1,62 @@
+---
+title: Invite Links and Join Requests
+parent: /#walkthrough
+prev: /chat-members
+next: /chat-settings
+---
+
+Invite links let people join a group, supergroup, or channel.
+
+## Creating an Invite Link
+
+Use {{ "createInviteLink" |> m }} to create an invite link.
+
+```ts
+const inviteLink = await client.createInviteLink(chatId, {
+  title: "Community invite",
+  limit: 100,
+});
+
+console.log(inviteLink.inviteLink);
+```
+
+Set `expireAt` to a future Unix timestamp in seconds to make the link temporary.
+
+## Requiring Approval
+
+Set `isApprovalRequired` to make users send a join request instead of joining immediately. It cannot be used together with `limit`.
+
+```ts
+const inviteLink = await client.createInviteLink(chatId, {
+  isApprovalRequired: true,
+});
+```
+
+User clients can use {{ "enableJoinRequests" |> m }} and {{ "disableJoinRequests" |> m }} to enable or disable join requests for a channel or supergroup.
+
+## Handling Join Requests
+
+Bots receive a `joinRequest` update containing the chat and the user who requested to join.
+
+```ts
+client.on("joinRequest", async (ctx) => {
+  const { chat, from } = ctx.update.joinRequest;
+  await client.approveJoinRequest(chat.id, from.id);
+});
+```
+
+Use {{ "declineJoinRequest" |> m }} to decline a request instead.
+
+## Listing Join Requests
+
+User clients can list pending requests with {{ "getJoinRequests" |> m }}.
+
+```ts
+const requests = await client.getJoinRequests(chatId);
+
+for (const request of requests) {
+  console.log(request.from.id, request.date);
+}
+```
+
+Use {{ "approveJoinRequests" |> m }} or {{ "declineJoinRequests" |> m }} to handle all pending requests at once.

src/polls.md

@@ -0,0 +1,80 @@
+---
+title: Polls
+parent: /#walkthrough
+prev: /rich-messages-and-text-formatting
+next: /checklists
+---
+
+Polls let users choose from a list of options directly in a chat. Use {{ "sendPoll" |> m }} with a question and an array of {{ "InputPollOption" |> t }} objects.
+
+## Sending a Poll
+
+```ts
+const message = await client.sendPoll(
+  chatId,
+  "Which runtime do you use?",
+  [
+    { text: "Deno" },
+    { text: "Node.js" },
+    { text: "Bun" },
+  ],
+);
+```
+
+Polls are anonymous by default. Set `isAnonymous` to `false` when individual votes must be visible. Regular polls can also allow more than one answer.
+
+```ts
+await client.sendPoll(chatId, "Which runtimes do you use?", [
+  { text: "Deno" },
+  { text: "Node.js" },
+  { text: "Bun" },
+], {
+  isAnonymous: false,
+  isMultipleAnswersAllowed: true,
+});
+```
+
+Within an update handler, use `ctx.replyPoll` to send the poll to the current chat.
+
+## Sending a Quiz
+
+A quiz has one or more correct options. Set `type` to `"quiz"` and provide their zero-based indexes. The optional explanation is shown after an answer is submitted.
+
+```ts
+await client.sendPoll(chatId, "What does MTProto power?", [
+  { text: "Telegram" },
+  { text: "Matrix" },
+], {
+  type: "quiz",
+  correctOptionIndexes: [0],
+  explanation: "MTProto is Telegram's protocol.",
+});
+```
+
+## Handling Poll Updates
+
+The `poll` update contains the latest state of a poll, including its options and total voter count.
+
+```ts
+client.on("poll", (ctx) => {
+  const { options, totalVoterCount } = ctx.update.poll;
+  console.log(options, totalVoterCount);
+});
+```
+
+For non-anonymous polls, `pollAnswer` contains the voter and the indexes they selected.
+
+```ts
+client.on("pollAnswer", (ctx) => {
+  const { pollId, from, optionIndexes } = ctx.update.pollAnswer;
+  console.log(pollId, from, optionIndexes);
+});
+```
+
+## Stopping a Poll
+
+Stop a poll with {{ "stopPoll" |> m }}. No more answers can be submitted after it is stopped.
+
+```ts
+await client.stopPoll(chatId, message.id);
+```

src/rich-messages-and-text-formatting.md

@@ -2,6 +2,7 @@
 title: Rich Messages and Text Formatting
 parent: /#walkthrough
 prev: /inline-queries
+next: /polls
 ---
 
 MTKruto supports both rich messages and formatted text messages. Rich messages contain structured page content such as headings, paragraphs, lists, tables, and media. Regular messages and media captions remain strings, with formatting described by message entities.