@inline-openclaw/inline 0.0.45 → 0.0.46

package/dist/approval-handler.runtime.js

@@ -5600,6 +5600,24 @@ var ConnectionError_Reason;
   ConnectionError_Reason2[ConnectionError_Reason2["INVALID_AUTH"] = 2] = "INVALID_AUTH";
   ConnectionError_Reason2[ConnectionError_Reason2["SESSION_REVOKED"] = 3] = "SESSION_REVOKED";
 })(ConnectionError_Reason || (ConnectionError_Reason = {}));
+var BotAvatar_Kind;
+(function(BotAvatar_Kind2) {
+  BotAvatar_Kind2[BotAvatar_Kind2["KIND_UNSPECIFIED"] = 0] = "KIND_UNSPECIFIED";
+  BotAvatar_Kind2[BotAvatar_Kind2["CODEX_ATLAS"] = 1] = "CODEX_ATLAS";
+})(BotAvatar_Kind || (BotAvatar_Kind = {}));
+var BotPresenceState_Kind;
+(function(BotPresenceState_Kind2) {
+  BotPresenceState_Kind2[BotPresenceState_Kind2["KIND_UNSPECIFIED"] = 0] = "KIND_UNSPECIFIED";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["HIDDEN"] = 1] = "HIDDEN";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["IDLE"] = 2] = "IDLE";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["HAPPY"] = 3] = "HAPPY";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["WAVING"] = 4] = "WAVING";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["JUMPING"] = 5] = "JUMPING";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["FAILED"] = 6] = "FAILED";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["WAITING"] = 7] = "WAITING";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["RUNNING"] = 8] = "RUNNING";
+  BotPresenceState_Kind2[BotPresenceState_Kind2["REVIEW"] = 9] = "REVIEW";
+})(BotPresenceState_Kind || (BotPresenceState_Kind = {}));
 var MessageEntity_Type;
 (function(MessageEntity_Type2) {
   MessageEntity_Type2[MessageEntity_Type2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
@@ -5713,6 +5731,11 @@ var UserStatus_Status;
   UserStatus_Status2[UserStatus_Status2["ONLINE"] = 1] = "ONLINE";
   UserStatus_Status2[UserStatus_Status2["OFFLINE"] = 2] = "OFFLINE";
 })(UserStatus_Status || (UserStatus_Status = {}));
+var DialogFollowMode;
+(function(DialogFollowMode2) {
+  DialogFollowMode2[DialogFollowMode2["DIALOG_FOLLOW_MODE_UNSPECIFIED"] = 0] = "DIALOG_FOLLOW_MODE_UNSPECIFIED";
+  DialogFollowMode2[DialogFollowMode2["FOLLOWING"] = 1] = "FOLLOWING";
+})(DialogFollowMode || (DialogFollowMode = {}));
 var MessageSendMode;
 (function(MessageSendMode2) {
   MessageSendMode2[MessageSendMode2["MODE_UNSPECIFIED"] = 0] = "MODE_UNSPECIFIED";
@@ -5776,6 +5799,11 @@ var Method;
   Method2[Method2["CLEAR_CHAT_HISTORY"] = 53] = "CLEAR_CHAT_HISTORY";
   Method2[Method2["DELETE_BOT"] = 54] = "DELETE_BOT";
   Method2[Method2["DELETE_MESSAGE_ATTACHMENT"] = 55] = "DELETE_MESSAGE_ATTACHMENT";
+  Method2[Method2["SET_BOT_AVATAR"] = 56] = "SET_BOT_AVATAR";
+  Method2[Method2["CLEAR_BOT_AVATAR"] = 57] = "CLEAR_BOT_AVATAR";
+  Method2[Method2["GET_BOT_PRESENCE"] = 58] = "GET_BOT_PRESENCE";
+  Method2[Method2["SET_BOT_PRESENCE_STATE"] = 59] = "SET_BOT_PRESENCE_STATE";
+  Method2[Method2["UPDATE_DIALOG_FOLLOW_MODE"] = 60] = "UPDATE_DIALOG_FOLLOW_MODE";
 })(Method || (Method = {}));
 var PushNotificationProvider;
 (function(PushNotificationProvider2) {
@@ -6658,6 +6686,123 @@ class PeerUser$Type extends import_runtime4.MessageType {
 }
 var PeerUser = new PeerUser$Type;
 
+class BotAvatar$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotAvatar", [
+      { no: 1, name: "kind", kind: "enum", T: () => ["BotAvatar.Kind", BotAvatar_Kind] },
+      { no: 2, name: "display_name", kind: "scalar", T: 9 },
+      { no: 3, name: "description", kind: "scalar", opt: true, T: 9 },
+      { no: 4, name: "cdn_url", kind: "scalar", opt: true, T: 9 },
+      { no: 5, name: "file_unique_id", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.kind = 0;
+    message.displayName = "";
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.kind = reader.int32();
+          break;
+        case 2:
+          message.displayName = reader.string();
+          break;
+        case 3:
+          message.description = reader.string();
+          break;
+        case 4:
+          message.cdnUrl = reader.string();
+          break;
+        case 5:
+          message.fileUniqueId = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.kind !== 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.kind);
+    if (message.displayName !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.displayName);
+    if (message.description !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.description);
+    if (message.cdnUrl !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.cdnUrl);
+    if (message.fileUniqueId !== undefined)
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.fileUniqueId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotAvatar = new BotAvatar$Type;
+
+class BotPresenceState$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotPresenceState", [
+      { no: 1, name: "kind", kind: "enum", T: () => ["BotPresenceState.Kind", BotPresenceState_Kind] },
+      { no: 2, name: "comment", kind: "scalar", opt: true, T: 9 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.kind = 0;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.kind = reader.int32();
+          break;
+        case 2:
+          message.comment = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.kind !== 0)
+      writer.tag(1, import_runtime.WireType.Varint).int32(message.kind);
+    if (message.comment !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.comment);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotPresenceState = new BotPresenceState$Type;
+
 class User$Type extends import_runtime4.MessageType {
   constructor() {
     super("User", [
@@ -6672,7 +6817,8 @@ class User$Type extends import_runtime4.MessageType {
       { no: 9, name: "profile_photo", kind: "message", T: () => UserProfilePhoto },
       { no: 11, name: "pending_setup", kind: "scalar", opt: true, T: 8 },
       { no: 12, name: "time_zone", kind: "scalar", opt: true, T: 9 },
-      { no: 13, name: "bot", kind: "scalar", opt: true, T: 8 }
+      { no: 13, name: "bot", kind: "scalar", opt: true, T: 8 },
+      { no: 14, name: "bot_avatar", kind: "message", T: () => BotAvatar }
     ]);
   }
   create(value) {
@@ -6723,6 +6869,9 @@ class User$Type extends import_runtime4.MessageType {
         case 13:
           message.bot = reader.bool();
           break;
+        case 14:
+          message.botAvatar = BotAvatar.internalBinaryRead(reader, reader.uint32(), options, message.botAvatar);
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -6759,6 +6908,8 @@ class User$Type extends import_runtime4.MessageType {
       writer.tag(12, import_runtime.WireType.LengthDelimited).string(message.timeZone);
     if (message.bot !== undefined)
       writer.tag(13, import_runtime.WireType.Varint).bool(message.bot);
+    if (message.botAvatar)
+      BotAvatar.internalBinaryWrite(message.botAvatar, writer.tag(14, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -6844,7 +6995,8 @@ class Dialog$Type extends import_runtime4.MessageType {
       { no: 11, name: "open", kind: "scalar", opt: true, T: 8 },
       { no: 12, name: "opened_date", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 14, name: "order", kind: "scalar", opt: true, T: 9 },
-      { no: 15, name: "pinned_order", kind: "scalar", opt: true, T: 9 }
+      { no: 15, name: "pinned_order", kind: "scalar", opt: true, T: 9 },
+      { no: 16, name: "follow_mode", kind: "enum", opt: true, T: () => ["DialogFollowMode", DialogFollowMode] }
     ]);
   }
   create(value) {
@@ -6903,6 +7055,9 @@ class Dialog$Type extends import_runtime4.MessageType {
         case 15:
           message.pinnedOrder = reader.string();
           break;
+        case 16:
+          message.followMode = reader.int32();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -6945,6 +7100,8 @@ class Dialog$Type extends import_runtime4.MessageType {
       writer.tag(14, import_runtime.WireType.LengthDelimited).string(message.order);
     if (message.pinnedOrder !== undefined)
       writer.tag(15, import_runtime.WireType.LengthDelimited).string(message.pinnedOrder);
+    if (message.followMode !== undefined)
+      writer.tag(16, import_runtime.WireType.Varint).int32(message.followMode);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -6968,7 +7125,8 @@ class Chat$Type extends import_runtime4.MessageType {
       { no: 10, name: "created_by", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 11, name: "parent_chat_id", kind: "scalar", opt: true, T: 3, L: 0 },
       { no: 12, name: "parent_message_id", kind: "scalar", opt: true, T: 3, L: 0 },
-      { no: 13, name: "untitled", kind: "scalar", opt: true, T: 8 }
+      { no: 13, name: "untitled", kind: "scalar", opt: true, T: 8 },
+      { no: 14, name: "number", kind: "scalar", opt: true, T: 5 }
     ]);
   }
   create(value) {
@@ -7023,6 +7181,9 @@ class Chat$Type extends import_runtime4.MessageType {
         case 13:
           message.untitled = reader.bool();
           break;
+        case 14:
+          message.number = reader.int32();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -7061,6 +7222,8 @@ class Chat$Type extends import_runtime4.MessageType {
       writer.tag(12, import_runtime.WireType.Varint).int64(message.parentMessageId);
     if (message.untitled !== undefined)
       writer.tag(13, import_runtime.WireType.Varint).bool(message.untitled);
+    if (message.number !== undefined)
+      writer.tag(14, import_runtime.WireType.Varint).int32(message.number);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -9909,7 +10072,12 @@ class RpcCall$Type extends import_runtime4.MessageType {
       { no: 53, name: "updateDialogOrder", kind: "message", oneof: "input", T: () => UpdateDialogOrderInput },
       { no: 54, name: "clearChatHistory", kind: "message", oneof: "input", T: () => ClearChatHistoryInput },
       { no: 55, name: "deleteBot", kind: "message", oneof: "input", T: () => DeleteBotInput },
-      { no: 56, name: "deleteMessageAttachment", kind: "message", oneof: "input", T: () => DeleteMessageAttachmentInput }
+      { no: 56, name: "deleteMessageAttachment", kind: "message", oneof: "input", T: () => DeleteMessageAttachmentInput },
+      { no: 57, name: "setBotAvatar", kind: "message", oneof: "input", T: () => SetBotAvatarInput },
+      { no: 58, name: "clearBotAvatar", kind: "message", oneof: "input", T: () => ClearBotAvatarInput },
+      { no: 59, name: "getBotPresence", kind: "message", oneof: "input", T: () => GetBotPresenceInput },
+      { no: 60, name: "setBotPresenceState", kind: "message", oneof: "input", T: () => SetBotPresenceStateInput },
+      { no: 61, name: "updateDialogFollowMode", kind: "message", oneof: "input", T: () => UpdateDialogFollowModeInput }
     ]);
   }
   create(value) {
@@ -10258,6 +10426,36 @@ class RpcCall$Type extends import_runtime4.MessageType {
             deleteMessageAttachment: DeleteMessageAttachmentInput.internalBinaryRead(reader, reader.uint32(), options, message.input.deleteMessageAttachment)
           };
           break;
+        case 57:
+          message.input = {
+            oneofKind: "setBotAvatar",
+            setBotAvatar: SetBotAvatarInput.internalBinaryRead(reader, reader.uint32(), options, message.input.setBotAvatar)
+          };
+          break;
+        case 58:
+          message.input = {
+            oneofKind: "clearBotAvatar",
+            clearBotAvatar: ClearBotAvatarInput.internalBinaryRead(reader, reader.uint32(), options, message.input.clearBotAvatar)
+          };
+          break;
+        case 59:
+          message.input = {
+            oneofKind: "getBotPresence",
+            getBotPresence: GetBotPresenceInput.internalBinaryRead(reader, reader.uint32(), options, message.input.getBotPresence)
+          };
+          break;
+        case 60:
+          message.input = {
+            oneofKind: "setBotPresenceState",
+            setBotPresenceState: SetBotPresenceStateInput.internalBinaryRead(reader, reader.uint32(), options, message.input.setBotPresenceState)
+          };
+          break;
+        case 61:
+          message.input = {
+            oneofKind: "updateDialogFollowMode",
+            updateDialogFollowMode: UpdateDialogFollowModeInput.internalBinaryRead(reader, reader.uint32(), options, message.input.updateDialogFollowMode)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -10382,6 +10580,16 @@ class RpcCall$Type extends import_runtime4.MessageType {
       DeleteBotInput.internalBinaryWrite(message.input.deleteBot, writer.tag(55, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.input.oneofKind === "deleteMessageAttachment")
       DeleteMessageAttachmentInput.internalBinaryWrite(message.input.deleteMessageAttachment, writer.tag(56, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "setBotAvatar")
+      SetBotAvatarInput.internalBinaryWrite(message.input.setBotAvatar, writer.tag(57, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "clearBotAvatar")
+      ClearBotAvatarInput.internalBinaryWrite(message.input.clearBotAvatar, writer.tag(58, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "getBotPresence")
+      GetBotPresenceInput.internalBinaryWrite(message.input.getBotPresence, writer.tag(59, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "setBotPresenceState")
+      SetBotPresenceStateInput.internalBinaryWrite(message.input.setBotPresenceState, writer.tag(60, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.input.oneofKind === "updateDialogFollowMode")
+      UpdateDialogFollowModeInput.internalBinaryWrite(message.input.updateDialogFollowMode, writer.tag(61, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -10448,7 +10656,12 @@ class RpcResult$Type extends import_runtime4.MessageType {
       { no: 53, name: "updateDialogOrder", kind: "message", oneof: "result", T: () => UpdateDialogOrderResult },
       { no: 54, name: "clearChatHistory", kind: "message", oneof: "result", T: () => ClearChatHistoryResult },
       { no: 55, name: "deleteBot", kind: "message", oneof: "result", T: () => DeleteBotResult },
-      { no: 56, name: "deleteMessageAttachment", kind: "message", oneof: "result", T: () => DeleteMessageAttachmentResult }
+      { no: 56, name: "deleteMessageAttachment", kind: "message", oneof: "result", T: () => DeleteMessageAttachmentResult },
+      { no: 57, name: "setBotAvatar", kind: "message", oneof: "result", T: () => SetBotAvatarResult },
+      { no: 58, name: "clearBotAvatar", kind: "message", oneof: "result", T: () => ClearBotAvatarResult },
+      { no: 59, name: "getBotPresence", kind: "message", oneof: "result", T: () => GetBotPresenceResult },
+      { no: 60, name: "setBotPresenceState", kind: "message", oneof: "result", T: () => SetBotPresenceStateResult },
+      { no: 61, name: "updateDialogFollowMode", kind: "message", oneof: "result", T: () => UpdateDialogFollowModeResult }
     ]);
   }
   create(value) {
@@ -10797,6 +11010,36 @@ class RpcResult$Type extends import_runtime4.MessageType {
             deleteMessageAttachment: DeleteMessageAttachmentResult.internalBinaryRead(reader, reader.uint32(), options, message.result.deleteMessageAttachment)
           };
           break;
+        case 57:
+          message.result = {
+            oneofKind: "setBotAvatar",
+            setBotAvatar: SetBotAvatarResult.internalBinaryRead(reader, reader.uint32(), options, message.result.setBotAvatar)
+          };
+          break;
+        case 58:
+          message.result = {
+            oneofKind: "clearBotAvatar",
+            clearBotAvatar: ClearBotAvatarResult.internalBinaryRead(reader, reader.uint32(), options, message.result.clearBotAvatar)
+          };
+          break;
+        case 59:
+          message.result = {
+            oneofKind: "getBotPresence",
+            getBotPresence: GetBotPresenceResult.internalBinaryRead(reader, reader.uint32(), options, message.result.getBotPresence)
+          };
+          break;
+        case 60:
+          message.result = {
+            oneofKind: "setBotPresenceState",
+            setBotPresenceState: SetBotPresenceStateResult.internalBinaryRead(reader, reader.uint32(), options, message.result.setBotPresenceState)
+          };
+          break;
+        case 61:
+          message.result = {
+            oneofKind: "updateDialogFollowMode",
+            updateDialogFollowMode: UpdateDialogFollowModeResult.internalBinaryRead(reader, reader.uint32(), options, message.result.updateDialogFollowMode)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -10921,6 +11164,16 @@ class RpcResult$Type extends import_runtime4.MessageType {
       DeleteBotResult.internalBinaryWrite(message.result.deleteBot, writer.tag(55, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.result.oneofKind === "deleteMessageAttachment")
       DeleteMessageAttachmentResult.internalBinaryWrite(message.result.deleteMessageAttachment, writer.tag(56, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "setBotAvatar")
+      SetBotAvatarResult.internalBinaryWrite(message.result.setBotAvatar, writer.tag(57, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "clearBotAvatar")
+      ClearBotAvatarResult.internalBinaryWrite(message.result.clearBotAvatar, writer.tag(58, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "getBotPresence")
+      GetBotPresenceResult.internalBinaryWrite(message.result.getBotPresence, writer.tag(59, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "setBotPresenceState")
+      SetBotPresenceStateResult.internalBinaryWrite(message.result.setBotPresenceState, writer.tag(60, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.result.oneofKind === "updateDialogFollowMode")
+      UpdateDialogFollowModeResult.internalBinaryWrite(message.result.updateDialogFollowMode, writer.tag(61, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -12012,6 +12265,97 @@ class UpdateDialogOrderResult$Type extends import_runtime4.MessageType {
 }
 var UpdateDialogOrderResult = new UpdateDialogOrderResult$Type;
 
+class UpdateDialogFollowModeInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateDialogFollowModeInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "follow_mode", kind: "enum", opt: true, T: () => ["DialogFollowMode", DialogFollowMode] }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.followMode = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.followMode !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.followMode);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateDialogFollowModeInput = new UpdateDialogFollowModeInput$Type;
+
+class UpdateDialogFollowModeResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateDialogFollowModeResult", [
+      { no: 1, name: "updates", kind: "message", repeat: 1, T: () => Update }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.updates = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.updates.length; i++)
+      Update.internalBinaryWrite(message.updates[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateDialogFollowModeResult = new UpdateDialogFollowModeResult$Type;
+
 class MarkAsUnreadInput$Type extends import_runtime4.MessageType {
   constructor() {
     super("MarkAsUnreadInput", [
@@ -12442,20 +12786,357 @@ class DeleteBotResult$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var DeleteBotResult = new DeleteBotResult$Type;
+var DeleteBotResult = new DeleteBotResult$Type;
+
+class DeleteMessageAttachmentInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("DeleteMessageAttachmentInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "message_id", kind: "scalar", T: 3, L: 0 },
+      { no: 3, name: "attachment_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.messageId = 0n;
+    message.attachmentId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.messageId = reader.int64().toBigInt();
+          break;
+        case 3:
+          message.attachmentId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.messageId !== 0n)
+      writer.tag(2, import_runtime.WireType.Varint).int64(message.messageId);
+    if (message.attachmentId !== 0n)
+      writer.tag(3, import_runtime.WireType.Varint).int64(message.attachmentId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var DeleteMessageAttachmentInput = new DeleteMessageAttachmentInput$Type;
+
+class DeleteMessageAttachmentResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("DeleteMessageAttachmentResult", [
+      { no: 1, name: "updates", kind: "message", repeat: 1, T: () => Update }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.updates = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.updates.length; i++)
+      Update.internalBinaryWrite(message.updates[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var DeleteMessageAttachmentResult = new DeleteMessageAttachmentResult$Type;
+
+class RevokeSessionInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RevokeSessionInput", [
+      { no: 1, name: "session_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.sessionId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.sessionId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.sessionId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.sessionId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RevokeSessionInput = new RevokeSessionInput$Type;
+
+class RevokeSessionResult$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("RevokeSessionResult", [
+      { no: 1, name: "revoked", kind: "scalar", T: 8 },
+      { no: 2, name: "already_revoked", kind: "scalar", T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.revoked = false;
+    message.alreadyRevoked = false;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.revoked = reader.bool();
+          break;
+        case 2:
+          message.alreadyRevoked = reader.bool();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.revoked !== false)
+      writer.tag(1, import_runtime.WireType.Varint).bool(message.revoked);
+    if (message.alreadyRevoked !== false)
+      writer.tag(2, import_runtime.WireType.Varint).bool(message.alreadyRevoked);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var RevokeSessionResult = new RevokeSessionResult$Type;
+
+class BotCommand$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("BotCommand", [
+      { no: 1, name: "command", kind: "scalar", T: 9 },
+      { no: 2, name: "description", kind: "scalar", T: 9 },
+      { no: 3, name: "sort_order", kind: "scalar", opt: true, T: 5 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.command = "";
+    message.description = "";
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.command = reader.string();
+          break;
+        case 2:
+          message.description = reader.string();
+          break;
+        case 3:
+          message.sortOrder = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.command !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.command);
+    if (message.description !== "")
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.description);
+    if (message.sortOrder !== undefined)
+      writer.tag(3, import_runtime.WireType.Varint).int32(message.sortOrder);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var BotCommand = new BotCommand$Type;
+
+class PeerBotCommands$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("PeerBotCommands", [
+      { no: 1, name: "bot", kind: "message", T: () => User },
+      { no: 2, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.commands = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
+          break;
+        case 2:
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.bot)
+      User.internalBinaryWrite(message.bot, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var PeerBotCommands = new PeerBotCommands$Type;
+
+class GetBotCommandsInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("GetBotCommandsInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetBotCommandsInput = new GetBotCommandsInput$Type;
 
-class DeleteMessageAttachmentInput$Type extends import_runtime4.MessageType {
+class GetBotCommandsResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("DeleteMessageAttachmentInput", [
-      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
-      { no: 2, name: "message_id", kind: "scalar", T: 3, L: 0 },
-      { no: 3, name: "attachment_id", kind: "scalar", T: 3, L: 0 }
+    super("GetBotCommandsResult", [
+      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.messageId = 0n;
-    message.attachmentId = 0n;
+    message.commands = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12466,13 +13147,55 @@ class DeleteMessageAttachmentInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
           break;
-        case 2:
-          message.messageId = reader.int64().toBigInt();
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0;i < message.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var GetBotCommandsResult = new GetBotCommandsResult$Type;
+
+class SetBotCommandsInput$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("SetBotCommandsInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    message.commands = [];
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.botUserId = reader.int64().toBigInt();
           break;
-        case 3:
-          message.attachmentId = reader.int64().toBigInt();
+        case 2:
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -12486,29 +13209,27 @@ class DeleteMessageAttachmentInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.peerId)
-      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    if (message.messageId !== 0n)
-      writer.tag(2, import_runtime.WireType.Varint).int64(message.messageId);
-    if (message.attachmentId !== 0n)
-      writer.tag(3, import_runtime.WireType.Varint).int64(message.attachmentId);
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    for (let i = 0;i < message.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var DeleteMessageAttachmentInput = new DeleteMessageAttachmentInput$Type;
+var SetBotCommandsInput = new SetBotCommandsInput$Type;
 
-class DeleteMessageAttachmentResult$Type extends import_runtime4.MessageType {
+class SetBotCommandsResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("DeleteMessageAttachmentResult", [
-      { no: 1, name: "updates", kind: "message", repeat: 1, T: () => Update }
+    super("SetBotCommandsResult", [
+      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.updates = [];
+    message.commands = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12519,7 +13240,7 @@ class DeleteMessageAttachmentResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.updates.push(Update.internalBinaryRead(reader, reader.uint32(), options));
+          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -12533,25 +13254,24 @@ class DeleteMessageAttachmentResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.updates.length; i++)
-      Update.internalBinaryWrite(message.updates[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0;i < message.commands.length; i++)
+      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var DeleteMessageAttachmentResult = new DeleteMessageAttachmentResult$Type;
+var SetBotCommandsResult = new SetBotCommandsResult$Type;
 
-class RevokeSessionInput$Type extends import_runtime4.MessageType {
+class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevokeSessionInput", [
-      { no: 1, name: "session_id", kind: "scalar", T: 3, L: 0 }
+    super("GetPeerBotCommandsInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.sessionId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12562,7 +13282,7 @@ class RevokeSessionInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.sessionId = reader.int64().toBigInt();
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         default:
           let u = options.readUnknownField;
@@ -12576,27 +13296,25 @@ class RevokeSessionInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.sessionId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.sessionId);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var RevokeSessionInput = new RevokeSessionInput$Type;
+var GetPeerBotCommandsInput = new GetPeerBotCommandsInput$Type;
 
-class RevokeSessionResult$Type extends import_runtime4.MessageType {
+class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevokeSessionResult", [
-      { no: 1, name: "revoked", kind: "scalar", T: 8 },
-      { no: 2, name: "already_revoked", kind: "scalar", T: 8 }
+    super("GetPeerBotCommandsResult", [
+      { no: 1, name: "bots", kind: "message", repeat: 1, T: () => PeerBotCommands }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.revoked = false;
-    message.alreadyRevoked = false;
+    message.bots = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12607,10 +13325,7 @@ class RevokeSessionResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.revoked = reader.bool();
-          break;
-        case 2:
-          message.alreadyRevoked = reader.bool();
+          message.bots.push(PeerBotCommands.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -12624,30 +13339,25 @@ class RevokeSessionResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.revoked !== false)
-      writer.tag(1, import_runtime.WireType.Varint).bool(message.revoked);
-    if (message.alreadyRevoked !== false)
-      writer.tag(2, import_runtime.WireType.Varint).bool(message.alreadyRevoked);
+    for (let i = 0;i < message.bots.length; i++)
+      PeerBotCommands.internalBinaryWrite(message.bots[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var RevokeSessionResult = new RevokeSessionResult$Type;
+var GetPeerBotCommandsResult = new GetPeerBotCommandsResult$Type;
 
-class BotCommand$Type extends import_runtime4.MessageType {
+class RevealBotTokenInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("BotCommand", [
-      { no: 1, name: "command", kind: "scalar", T: 9 },
-      { no: 2, name: "description", kind: "scalar", T: 9 },
-      { no: 3, name: "sort_order", kind: "scalar", opt: true, T: 5 }
+    super("RevealBotTokenInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.command = "";
-    message.description = "";
+    message.botUserId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12658,13 +13368,7 @@ class BotCommand$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.command = reader.string();
-          break;
-        case 2:
-          message.description = reader.string();
-          break;
-        case 3:
-          message.sortOrder = reader.int32();
+          message.botUserId = reader.int64().toBigInt();
           break;
         default:
           let u = options.readUnknownField;
@@ -12678,30 +13382,25 @@ class BotCommand$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.command !== "")
-      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.command);
-    if (message.description !== "")
-      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.description);
-    if (message.sortOrder !== undefined)
-      writer.tag(3, import_runtime.WireType.Varint).int32(message.sortOrder);
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var BotCommand = new BotCommand$Type;
+var RevealBotTokenInput = new RevealBotTokenInput$Type;
 
-class PeerBotCommands$Type extends import_runtime4.MessageType {
+class RevealBotTokenResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("PeerBotCommands", [
-      { no: 1, name: "bot", kind: "message", T: () => User },
-      { no: 2, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    super("RevealBotTokenResult", [
+      { no: 1, name: "token", kind: "scalar", T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.commands = [];
+    message.token = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12712,10 +13411,7 @@ class PeerBotCommands$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
-          break;
-        case 2:
-          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          message.token = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -12729,21 +13425,19 @@ class PeerBotCommands$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.bot)
-      User.internalBinaryWrite(message.bot, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
-    for (let i = 0;i < message.commands.length; i++)
-      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.token !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.token);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var PeerBotCommands = new PeerBotCommands$Type;
+var RevealBotTokenResult = new RevealBotTokenResult$Type;
 
-class GetBotCommandsInput$Type extends import_runtime4.MessageType {
+class RotateBotTokenInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetBotCommandsInput", [
+    super("RotateBotTokenInput", [
       { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
     ]);
   }
@@ -12782,17 +13476,17 @@ class GetBotCommandsInput$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var GetBotCommandsInput = new GetBotCommandsInput$Type;
+var RotateBotTokenInput = new RotateBotTokenInput$Type;
 
-class GetBotCommandsResult$Type extends import_runtime4.MessageType {
+class RotateBotTokenResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetBotCommandsResult", [
-      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    super("RotateBotTokenResult", [
+      { no: 1, name: "token", kind: "scalar", T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.commands = [];
+    message.token = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12803,7 +13497,7 @@ class GetBotCommandsResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          message.token = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -12817,27 +13511,27 @@ class GetBotCommandsResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.commands.length; i++)
-      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.token !== "")
+      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.token);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var GetBotCommandsResult = new GetBotCommandsResult$Type;
+var RotateBotTokenResult = new RotateBotTokenResult$Type;
 
-class SetBotCommandsInput$Type extends import_runtime4.MessageType {
+class UpdateBotProfileInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("SetBotCommandsInput", [
+    super("UpdateBotProfileInput", [
       { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
-      { no: 2, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+      { no: 2, name: "name", kind: "scalar", opt: true, T: 9 },
+      { no: 3, name: "photo_file_unique_id", kind: "scalar", opt: true, T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
     message.botUserId = 0n;
-    message.commands = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12851,7 +13545,10 @@ class SetBotCommandsInput$Type extends import_runtime4.MessageType {
           message.botUserId = reader.int64().toBigInt();
           break;
         case 2:
-          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          message.name = reader.string();
+          break;
+        case 3:
+          message.photoFileUniqueId = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -12867,25 +13564,26 @@ class SetBotCommandsInput$Type extends import_runtime4.MessageType {
   internalBinaryWrite(message, writer, options) {
     if (message.botUserId !== 0n)
       writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
-    for (let i = 0;i < message.commands.length; i++)
-      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.name !== undefined)
+      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.name);
+    if (message.photoFileUniqueId !== undefined)
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.photoFileUniqueId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var SetBotCommandsInput = new SetBotCommandsInput$Type;
+var UpdateBotProfileInput = new UpdateBotProfileInput$Type;
 
-class SetBotCommandsResult$Type extends import_runtime4.MessageType {
+class UpdateBotProfileResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("SetBotCommandsResult", [
-      { no: 1, name: "commands", kind: "message", repeat: 1, T: () => BotCommand }
+    super("UpdateBotProfileResult", [
+      { no: 1, name: "bot", kind: "message", T: () => User }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.commands = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12896,7 +13594,7 @@ class SetBotCommandsResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.commands.push(BotCommand.internalBinaryRead(reader, reader.uint32(), options));
+          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
           break;
         default:
           let u = options.readUnknownField;
@@ -12910,24 +13608,32 @@ class SetBotCommandsResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.commands.length; i++)
-      BotCommand.internalBinaryWrite(message.commands[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.bot)
+      User.internalBinaryWrite(message.bot, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var SetBotCommandsResult = new SetBotCommandsResult$Type;
+var UpdateBotProfileResult = new UpdateBotProfileResult$Type;
 
-class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
+class SetBotAvatarInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetPeerBotCommandsInput", [
-      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
+    super("SetBotAvatarInput", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "kind", kind: "enum", T: () => ["BotAvatar.Kind", BotAvatar_Kind] },
+      { no: 3, name: "display_name", kind: "scalar", T: 9 },
+      { no: 4, name: "description", kind: "scalar", opt: true, T: 9 },
+      { no: 5, name: "file_unique_id", kind: "scalar", T: 9 }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    message.kind = 0;
+    message.displayName = "";
+    message.fileUniqueId = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12938,7 +13644,19 @@ class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.kind = reader.int32();
+          break;
+        case 3:
+          message.displayName = reader.string();
+          break;
+        case 4:
+          message.description = reader.string();
+          break;
+        case 5:
+          message.fileUniqueId = reader.string();
           break;
         default:
           let u = options.readUnknownField;
@@ -12952,25 +13670,32 @@ class GetPeerBotCommandsInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.peerId)
-      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.kind !== 0)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.kind);
+    if (message.displayName !== "")
+      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.displayName);
+    if (message.description !== undefined)
+      writer.tag(4, import_runtime.WireType.LengthDelimited).string(message.description);
+    if (message.fileUniqueId !== "")
+      writer.tag(5, import_runtime.WireType.LengthDelimited).string(message.fileUniqueId);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var GetPeerBotCommandsInput = new GetPeerBotCommandsInput$Type;
+var SetBotAvatarInput = new SetBotAvatarInput$Type;
 
-class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
+class SetBotAvatarResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("GetPeerBotCommandsResult", [
-      { no: 1, name: "bots", kind: "message", repeat: 1, T: () => PeerBotCommands }
+    super("SetBotAvatarResult", [
+      { no: 1, name: "bot", kind: "message", T: () => User }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.bots = [];
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -12981,7 +13706,7 @@ class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.bots.push(PeerBotCommands.internalBinaryRead(reader, reader.uint32(), options));
+          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
           break;
         default:
           let u = options.readUnknownField;
@@ -12995,19 +13720,19 @@ class GetPeerBotCommandsResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    for (let i = 0;i < message.bots.length; i++)
-      PeerBotCommands.internalBinaryWrite(message.bots[i], writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.bot)
+      User.internalBinaryWrite(message.bot, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var GetPeerBotCommandsResult = new GetPeerBotCommandsResult$Type;
+var SetBotAvatarResult = new SetBotAvatarResult$Type;
 
-class RevealBotTokenInput$Type extends import_runtime4.MessageType {
+class ClearBotAvatarInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevealBotTokenInput", [
+    super("ClearBotAvatarInput", [
       { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
     ]);
   }
@@ -13046,17 +13771,16 @@ class RevealBotTokenInput$Type extends import_runtime4.MessageType {
     return writer;
   }
 }
-var RevealBotTokenInput = new RevealBotTokenInput$Type;
+var ClearBotAvatarInput = new ClearBotAvatarInput$Type;
 
-class RevealBotTokenResult$Type extends import_runtime4.MessageType {
+class ClearBotAvatarResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RevealBotTokenResult", [
-      { no: 1, name: "token", kind: "scalar", T: 9 }
+    super("ClearBotAvatarResult", [
+      { no: 1, name: "bot", kind: "message", T: () => User }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.token = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13067,7 +13791,7 @@ class RevealBotTokenResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.token = reader.string();
+          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
           break;
         default:
           let u = options.readUnknownField;
@@ -13081,25 +13805,24 @@ class RevealBotTokenResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.token !== "")
-      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.token);
+    if (message.bot)
+      User.internalBinaryWrite(message.bot, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var RevealBotTokenResult = new RevealBotTokenResult$Type;
+var ClearBotAvatarResult = new ClearBotAvatarResult$Type;
 
-class RotateBotTokenInput$Type extends import_runtime4.MessageType {
+class GetBotPresenceInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RotateBotTokenInput", [
-      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 }
+    super("GetBotPresenceInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.botUserId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13110,7 +13833,7 @@ class RotateBotTokenInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.botUserId = reader.int64().toBigInt();
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         default:
           let u = options.readUnknownField;
@@ -13124,25 +13847,27 @@ class RotateBotTokenInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.botUserId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var RotateBotTokenInput = new RotateBotTokenInput$Type;
+var GetBotPresenceInput = new GetBotPresenceInput$Type;
 
-class RotateBotTokenResult$Type extends import_runtime4.MessageType {
+class GetBotPresenceResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("RotateBotTokenResult", [
-      { no: 1, name: "token", kind: "scalar", T: 9 }
+    super("GetBotPresenceResult", [
+      { no: 1, name: "bot_user_id", kind: "scalar", opt: true, T: 3, L: 0 },
+      { no: 2, name: "avatar", kind: "message", T: () => BotAvatar },
+      { no: 3, name: "state", kind: "message", T: () => BotPresenceState },
+      { no: 4, name: "peer_id", kind: "message", T: () => Peer }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.token = "";
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13153,7 +13878,16 @@ class RotateBotTokenResult$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.token = reader.string();
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.avatar = BotAvatar.internalBinaryRead(reader, reader.uint32(), options, message.avatar);
+          break;
+        case 3:
+          message.state = BotPresenceState.internalBinaryRead(reader, reader.uint32(), options, message.state);
+          break;
+        case 4:
+          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         default:
           let u = options.readUnknownField;
@@ -13167,27 +13901,31 @@ class RotateBotTokenResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.token !== "")
-      writer.tag(1, import_runtime.WireType.LengthDelimited).string(message.token);
+    if (message.botUserId !== undefined)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.avatar)
+      BotAvatar.internalBinaryWrite(message.avatar, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state)
+      BotPresenceState.internalBinaryWrite(message.state, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.peerId)
+      Peer.internalBinaryWrite(message.peerId, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var RotateBotTokenResult = new RotateBotTokenResult$Type;
+var GetBotPresenceResult = new GetBotPresenceResult$Type;
 
-class UpdateBotProfileInput$Type extends import_runtime4.MessageType {
+class SetBotPresenceStateInput$Type extends import_runtime4.MessageType {
   constructor() {
-    super("UpdateBotProfileInput", [
-      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
-      { no: 2, name: "name", kind: "scalar", opt: true, T: 9 },
-      { no: 3, name: "photo_file_unique_id", kind: "scalar", opt: true, T: 9 }
+    super("SetBotPresenceStateInput", [
+      { no: 1, name: "peer_id", kind: "message", T: () => InputPeer },
+      { no: 2, name: "state", kind: "message", T: () => BotPresenceState }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.botUserId = 0n;
     if (value !== undefined)
       import_runtime3.reflectionMergePartial(this, message, value);
     return message;
@@ -13198,13 +13936,10 @@ class UpdateBotProfileInput$Type extends import_runtime4.MessageType {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case 1:
-          message.botUserId = reader.int64().toBigInt();
+          message.peerId = InputPeer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
           break;
         case 2:
-          message.name = reader.string();
-          break;
-        case 3:
-          message.photoFileUniqueId = reader.string();
+          message.state = BotPresenceState.internalBinaryRead(reader, reader.uint32(), options, message.state);
           break;
         default:
           let u = options.readUnknownField;
@@ -13218,25 +13953,21 @@ class UpdateBotProfileInput$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.botUserId !== 0n)
-      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
-    if (message.name !== undefined)
-      writer.tag(2, import_runtime.WireType.LengthDelimited).string(message.name);
-    if (message.photoFileUniqueId !== undefined)
-      writer.tag(3, import_runtime.WireType.LengthDelimited).string(message.photoFileUniqueId);
+    if (message.peerId)
+      InputPeer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state)
+      BotPresenceState.internalBinaryWrite(message.state, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var UpdateBotProfileInput = new UpdateBotProfileInput$Type;
+var SetBotPresenceStateInput = new SetBotPresenceStateInput$Type;
 
-class UpdateBotProfileResult$Type extends import_runtime4.MessageType {
+class SetBotPresenceStateResult$Type extends import_runtime4.MessageType {
   constructor() {
-    super("UpdateBotProfileResult", [
-      { no: 1, name: "bot", kind: "message", T: () => User }
-    ]);
+    super("SetBotPresenceStateResult", []);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
@@ -13245,34 +13976,16 @@ class UpdateBotProfileResult$Type extends import_runtime4.MessageType {
     return message;
   }
   internalBinaryRead(reader, length, options, target) {
-    let message = target ?? this.create(), end = reader.pos + length;
-    while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
-      switch (fieldNo) {
-        case 1:
-          message.bot = User.internalBinaryRead(reader, reader.uint32(), options, message.bot);
-          break;
-        default:
-          let u = options.readUnknownField;
-          if (u === "throw")
-            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-          let d = reader.skip(wireType);
-          if (u !== false)
-            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-      }
-    }
-    return message;
+    return target ?? this.create();
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.bot)
-      User.internalBinaryWrite(message.bot, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 }
-var UpdateBotProfileResult = new UpdateBotProfileResult$Type;
+var SetBotPresenceStateResult = new SetBotPresenceStateResult$Type;
 
 class GetUserSettingsInput$Type extends import_runtime4.MessageType {
   constructor() {
@@ -16412,7 +17125,9 @@ class Update$Type extends import_runtime4.MessageType {
       { no: 34, name: "chat_open", kind: "message", oneof: "update", T: () => UpdateChatOpen },
       { no: 35, name: "message_action_invoked", kind: "message", oneof: "update", T: () => UpdateMessageActionInvoked },
       { no: 36, name: "message_action_answered", kind: "message", oneof: "update", T: () => UpdateMessageActionAnswered },
-      { no: 37, name: "clear_chat_history", kind: "message", oneof: "update", T: () => UpdateClearChatHistory }
+      { no: 37, name: "clear_chat_history", kind: "message", oneof: "update", T: () => UpdateClearChatHistory },
+      { no: 38, name: "bot_presence", kind: "message", oneof: "update", T: () => UpdateBotPresence },
+      { no: 39, name: "dialog_follow_mode", kind: "message", oneof: "update", T: () => UpdateDialogFollowMode }
     ]);
   }
   create(value) {
@@ -16637,6 +17352,18 @@ class Update$Type extends import_runtime4.MessageType {
             clearChatHistory: UpdateClearChatHistory.internalBinaryRead(reader, reader.uint32(), options, message.update.clearChatHistory)
           };
           break;
+        case 38:
+          message.update = {
+            oneofKind: "botPresence",
+            botPresence: UpdateBotPresence.internalBinaryRead(reader, reader.uint32(), options, message.update.botPresence)
+          };
+          break;
+        case 39:
+          message.update = {
+            oneofKind: "dialogFollowMode",
+            dialogFollowMode: UpdateDialogFollowMode.internalBinaryRead(reader, reader.uint32(), options, message.update.dialogFollowMode)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -16721,6 +17448,10 @@ class Update$Type extends import_runtime4.MessageType {
       UpdateMessageActionAnswered.internalBinaryWrite(message.update.messageActionAnswered, writer.tag(36, import_runtime.WireType.LengthDelimited).fork(), options).join();
     if (message.update.oneofKind === "clearChatHistory")
       UpdateClearChatHistory.internalBinaryWrite(message.update.clearChatHistory, writer.tag(37, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.update.oneofKind === "botPresence")
+      UpdateBotPresence.internalBinaryWrite(message.update.botPresence, writer.tag(38, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.update.oneofKind === "dialogFollowMode")
+      UpdateDialogFollowMode.internalBinaryWrite(message.update.dialogFollowMode, writer.tag(39, import_runtime.WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -17581,6 +18312,54 @@ class UpdateDialogNotificationSettings$Type extends import_runtime4.MessageType
 }
 var UpdateDialogNotificationSettings = new UpdateDialogNotificationSettings$Type;
 
+class UpdateDialogFollowMode$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateDialogFollowMode", [
+      { no: 1, name: "peer_id", kind: "message", T: () => Peer },
+      { no: 2, name: "follow_mode", kind: "enum", opt: true, T: () => ["DialogFollowMode", DialogFollowMode] }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 2:
+          message.followMode = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.peerId)
+      Peer.internalBinaryWrite(message.peerId, writer.tag(1, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.followMode !== undefined)
+      writer.tag(2, import_runtime.WireType.Varint).int32(message.followMode);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateDialogFollowMode = new UpdateDialogFollowMode$Type;
+
 class UpdateNewChat$Type extends import_runtime4.MessageType {
   constructor() {
     super("UpdateNewChat", [
@@ -18106,6 +18885,74 @@ class UpdateClearChatHistory$Type extends import_runtime4.MessageType {
 }
 var UpdateClearChatHistory = new UpdateClearChatHistory$Type;
 
+class UpdateBotPresence$Type extends import_runtime4.MessageType {
+  constructor() {
+    super("UpdateBotPresence", [
+      { no: 1, name: "bot_user_id", kind: "scalar", T: 3, L: 0 },
+      { no: 2, name: "peer_id", kind: "message", T: () => Peer },
+      { no: 3, name: "state", kind: "message", T: () => BotPresenceState },
+      { no: 4, name: "avatar", kind: "message", T: () => BotAvatar },
+      { no: 5, name: "avatar_changed", kind: "scalar", T: 8 }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.botUserId = 0n;
+    message.avatarChanged = false;
+    if (value !== undefined)
+      import_runtime3.reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          message.botUserId = reader.int64().toBigInt();
+          break;
+        case 2:
+          message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+          break;
+        case 3:
+          message.state = BotPresenceState.internalBinaryRead(reader, reader.uint32(), options, message.state);
+          break;
+        case 4:
+          message.avatar = BotAvatar.internalBinaryRead(reader, reader.uint32(), options, message.avatar);
+          break;
+        case 5:
+          message.avatarChanged = reader.bool();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? import_runtime2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.botUserId !== 0n)
+      writer.tag(1, import_runtime.WireType.Varint).int64(message.botUserId);
+    if (message.peerId)
+      Peer.internalBinaryWrite(message.peerId, writer.tag(2, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.state)
+      BotPresenceState.internalBinaryWrite(message.state, writer.tag(3, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.avatar)
+      BotAvatar.internalBinaryWrite(message.avatar, writer.tag(4, import_runtime.WireType.LengthDelimited).fork(), options).join();
+    if (message.avatarChanged !== false)
+      writer.tag(5, import_runtime.WireType.Varint).bool(message.avatarChanged);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? import_runtime2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+var UpdateBotPresence = new UpdateBotPresence$Type;
+
 class UpdateMessageId$Type extends import_runtime4.MessageType {
   constructor() {
     super("UpdateMessageId", [
@@ -37303,6 +38150,80 @@ async function uploadInlineMediaFromUrl(params) {
   }
 }
 
+// src/inline/message-formatting.ts
+var INLINE_FORMATTING_RULES = [
+  "Use Inline markdown.",
+  "Prefer bullet lists over markdown tables.",
+  "If a table is necessary, render it inside a fenced code block.",
+  "Use plain URLs or markdown links; do not wrap bare URLs in inline code or backticks.",
+  "Mention Inline users with markdown links like [@FirstName](inline://user?id=123); use inline://user?username=username only when the user id is unavailable.",
+  "Link Inline chats/threads with markdown links like [Planning](inline://chat?id=123) or [Planning](inline://thread?id=123); use inline://thread?space_id=7 when only the title and space are known.",
+  "Use inline code only for actual code, commands, file paths, env vars, or identifiers."
+];
+var INLINE_COPY_REPLACEMENTS = [
+  [
+    /Bind this (?:thread \(Discord\) or topic\/conversation \(Telegram\)|thread or topic\/conversation) to a session target\.?/gi,
+    "Bind this Inline conversation to a session target."
+  ],
+  [
+    /Remove the current (?:thread \(Discord\) or topic\/conversation \(Telegram\)|thread or topic\/conversation) binding\.?/gi,
+    "Remove the current Inline conversation binding."
+  ]
+];
+function normalizeInlineMarkdownLabel(raw, fallback) {
+  return (raw ?? "").replace(/\s+/g, " ").trim() || fallback;
+}
+function escapeInlineMarkdownLabel(raw) {
+  return raw.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+function encodeInlineMarkdownValue(raw) {
+  return encodeURIComponent(String(raw).trim());
+}
+function isBareHttpUrl(text) {
+  if (!/^https?:\/\/\S+$/i.test(text))
+    return false;
+  try {
+    const url2 = new URL(text);
+    return url2.protocol === "http:" || url2.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function adaptInlineVisibleCopy(text) {
+  let result = text;
+  for (const [from, to] of INLINE_COPY_REPLACEMENTS) {
+    result = result.replace(from, to);
+  }
+  return result;
+}
+function buildInlineSystemPrompt(extraPrompt) {
+  return extraPrompt?.trim() || "";
+}
+function buildInlineInboundFormattingHints() {
+  return {
+    text_markup: "inline_markdown",
+    rules: [...INLINE_FORMATTING_RULES]
+  };
+}
+function buildInlineThreadMarkdownLink(params) {
+  const title = normalizeInlineMarkdownLabel(params.title, `thread:${String(params.threadId)}`);
+  return `[${escapeInlineMarkdownLabel(title)}](inline://thread?id=${encodeInlineMarkdownValue(params.threadId)})`;
+}
+function buildInlineThreadTitleMarkdownLink(params) {
+  const title = normalizeInlineMarkdownLabel(params.title, `space:${String(params.spaceId)}`);
+  const label = normalizeInlineMarkdownLabel(params.label, title);
+  const query = [`space_id=${encodeInlineMarkdownValue(params.spaceId)}`];
+  if (label !== title) {
+    query.push(`title=${encodeInlineMarkdownValue(title)}`);
+  }
+  return `[${escapeInlineMarkdownLabel(label)}](inline://thread?${query.join("&")})`;
+}
+function sanitizeInlineOutgoingText(text) {
+  return adaptInlineVisibleCopy(text).replace(/`([^`\n]+)`/g, (full, content) => {
+    return isBareHttpUrl(content) ? content : full;
+  });
+}
+
 // src/inline/message-content.ts
 var INLINE_MESSAGE_ENTITY_TYPE = {
   MENTION: 1,
@@ -37314,7 +38235,9 @@ var INLINE_MESSAGE_ENTITY_TYPE = {
   USERNAME_MENTION: 7,
   CODE: 8,
   PRE: 9,
-  PHONE_NUMBER: 10
+  PHONE_NUMBER: 10,
+  THREAD: 11,
+  THREAD_TITLE: 12
 };
 function compactWhitespace(raw) {
   return (raw ?? "").replace(/\s+/g, " ").trim();
@@ -37482,6 +38405,10 @@ function mapEntityType(type) {
       return "pre";
     case INLINE_MESSAGE_ENTITY_TYPE.PHONE_NUMBER:
       return "phone_number";
+    case INLINE_MESSAGE_ENTITY_TYPE.THREAD:
+      return "thread";
+    case INLINE_MESSAGE_ENTITY_TYPE.THREAD_TITLE:
+      return "thread_title";
     default:
       return "unknown";
   }
@@ -37523,6 +38450,26 @@ function messageEntitySummaries(message) {
       const language = compactWhitespace(entity.entity.pre.language);
       if (language)
         summary.language = language;
+    } else if (entity.entity.oneofKind === "thread") {
+      const chatId = entity.entity.thread.chatId.toString();
+      summary.chatId = chatId;
+      summary.markdownLink = buildInlineThreadMarkdownLink({
+        threadId: chatId,
+        ...summary.text ? { title: summary.text } : {}
+      });
+    } else if (entity.entity.oneofKind === "threadTitle") {
+      const spaceId = entity.entity.threadTitle.spaceId.toString();
+      const title = compactWhitespace(entity.entity.threadTitle.title);
+      summary.spaceId = spaceId;
+      if (title)
+        summary.title = title;
+      if (title || summary.text) {
+        summary.markdownLink = buildInlineThreadTitleMarkdownLink({
+          spaceId,
+          title: title || summary.text || `space:${spaceId}`,
+          label: summary.text || title
+        });
+      }
     }
     entities.push(summary);
   }
@@ -37575,6 +38522,13 @@ function formatEntitySummary(entity) {
       return entity.userId ? `mention${quotedText} -> user:${entity.userId}` : `mention${quotedText}`;
     case "text_link":
       return entity.url ? `text link${quotedText} -> ${entity.url}` : `text link${quotedText}`;
+    case "thread":
+      return entity.chatId ? `thread link${quotedText} -> thread:${entity.chatId}` : `thread link${quotedText}`;
+    case "thread_title":
+      if (entity.spaceId && entity.title) {
+        return `thread title link${quotedText} -> space:${entity.spaceId} title:"${entity.title}"`;
+      }
+      return entity.spaceId ? `thread title link${quotedText} -> space:${entity.spaceId}` : `thread title link${quotedText}`;
     case "pre":
       return entity.language ? `preformatted block${quotedText} (language: ${entity.language})` : `preformatted block${quotedText}`;
     case "username_mention":
@@ -37619,57 +38573,6 @@ function summarizeInlineMessageContent(message) {
   };
 }
 
-// src/inline/message-formatting.ts
-var INLINE_FORMATTING_RULES = [
-  "Use Inline markdown.",
-  "Prefer bullet lists over markdown tables.",
-  "If a table is necessary, render it inside a fenced code block.",
-  "Use plain URLs or markdown links; do not wrap bare URLs in inline code or backticks.",
-  "Mention Inline users with markdown links like [@FirstName](inline://user?id=123); use inline://user?username=username only when the user id is unavailable.",
-  "Use inline code only for actual code, commands, file paths, env vars, or identifiers."
-];
-var INLINE_COPY_REPLACEMENTS = [
-  [
-    /Bind this (?:thread \(Discord\) or topic\/conversation \(Telegram\)|thread or topic\/conversation) to a session target\.?/gi,
-    "Bind this Inline conversation to a session target."
-  ],
-  [
-    /Remove the current (?:thread \(Discord\) or topic\/conversation \(Telegram\)|thread or topic\/conversation) binding\.?/gi,
-    "Remove the current Inline conversation binding."
-  ]
-];
-function isBareHttpUrl(text) {
-  if (!/^https?:\/\/\S+$/i.test(text))
-    return false;
-  try {
-    const url2 = new URL(text);
-    return url2.protocol === "http:" || url2.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-function adaptInlineVisibleCopy(text) {
-  let result = text;
-  for (const [from, to] of INLINE_COPY_REPLACEMENTS) {
-    result = result.replace(from, to);
-  }
-  return result;
-}
-function buildInlineSystemPrompt(extraPrompt) {
-  return extraPrompt?.trim() || "";
-}
-function buildInlineInboundFormattingHints() {
-  return {
-    text_markup: "inline_markdown",
-    rules: [...INLINE_FORMATTING_RULES]
-  };
-}
-function sanitizeInlineOutgoingText(text) {
-  return adaptInlineVisibleCopy(text).replace(/`([^`\n]+)`/g, (full, content) => {
-    return isBareHttpUrl(content) ? content : full;
-  });
-}
-
 // src/inline/normalize.ts
 function normalizeInlineTarget(raw) {
   let normalized = raw.trim();
@@ -38381,6 +39284,46 @@ var GET_MESSAGES_METHOD = typeof Method.GET_MESSAGES === "number" && Number.isIn
 var CREATE_SUBTHREAD_METHOD = typeof Method.CREATE_SUBTHREAD === "number" && Number.isInteger(Method.CREATE_SUBTHREAD) && Method.CREATE_SUBTHREAD > 0 ? Method.CREATE_SUBTHREAD : 42;
 var INLINE_ACTION_MAX_ROWS = 8;
 var INLINE_ACTION_MAX_PER_ROW = 8;
+var INLINE_BOT_PRESENCE_KINDS = [
+  "idle",
+  "happy",
+  "waving",
+  "jumping",
+  "failed",
+  "waiting",
+  "running",
+  "review"
+];
+var inlineBotPresenceChannelDataSchema = {
+  type: "object",
+  description: "Inline-specific metadata for a send. Use inline.botPresence for the bot's on-screen body.",
+  additionalProperties: true,
+  properties: {
+    inline: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        botPresence: {
+          type: "object",
+          description: "Optional Inline bot presence state generated from your current mood or process.",
+          additionalProperties: true,
+          properties: {
+            kind: {
+              type: "string",
+              enum: INLINE_BOT_PRESENCE_KINDS,
+              description: "Emotion/state for the on-screen bot presence."
+            },
+            comment: {
+              type: "string",
+              maxLength: 30,
+              description: "Optional short expression from your actual current thought, status, mood, request, or aside. Text or one/two emoji."
+            }
+          }
+        }
+      }
+    }
+  }
+};
 function suppressedInternalTextResult() {
   return jsonResult({
     ok: false,
@@ -39137,14 +40080,24 @@ function describeInlineMessageTool({
     };
   }
   const buttonsEnabled = supportsInlineMessageButtons(actions);
+  const sendEnabled = actions.includes("send");
   const capabilities = buttonsEnabled ? ["presentation"] : [];
-  const schema = buttonsEnabled ? [
-    {
+  const schema = [];
+  if (buttonsEnabled) {
+    schema.push({
       properties: {
         buttons: createMessageToolButtonsSchema()
       }
-    }
-  ] : [];
+    });
+  }
+  if (sendEnabled) {
+    schema.push({
+      actions: ["send"],
+      properties: {
+        channelData: inlineBotPresenceChannelDataSchema
+      }
+    });
+  }
   return {
     actions,
     capabilities,
@@ -40397,6 +41350,23 @@ function buildUserPeer(userId) {
     }
   };
 }
+async function sendInlineBotPresenceState(client, chatId, kind) {
+  const invokeRaw = client.invokeRaw;
+  if (typeof invokeRaw !== "function")
+    return;
+  await invokeRaw.call(client, Method.SET_BOT_PRESENCE_STATE, {
+    oneofKind: "setBotPresenceState",
+    setBotPresenceState: {
+      peerId: {
+        type: {
+          oneofKind: "chat",
+          chat: { chatId }
+        }
+      },
+      state: { kind }
+    }
+  }).catch(() => {});
+}
 function buildInlineApprovalActions(view) {
   const buttons = [
     view.actions.map((action) => ({
@@ -40500,8 +41470,12 @@ var inlineApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
       if (!resolved) {
         return null;
       }
+      let delivered = false;
       if (preparedTarget.typingChatId != null) {
-        await resolved.context.client.sendTyping({ chatId: preparedTarget.typingChatId, typing: true }).catch(() => {});
+        await Promise.all([
+          resolved.context.client.sendTyping({ chatId: preparedTarget.typingChatId, typing: true }).catch(() => {}),
+          sendInlineBotPresenceState(resolved.context.client, preparedTarget.typingChatId, BotPresenceState_Kind.WAITING)
+        ]);
       }
       try {
         const result = await resolved.context.client.sendMessage({
@@ -40513,15 +41487,20 @@ var inlineApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
         if (result.messageId == null) {
           return null;
         }
+        delivered = true;
         return {
           messageId: result.messageId,
           peerId: preparedTarget.peerId,
           text: pendingPayload.text,
-          parseMarkdown: resolved.context.parseMarkdown ?? true
+          parseMarkdown: resolved.context.parseMarkdown ?? true,
+          ...preparedTarget.typingChatId != null ? { typingChatId: preparedTarget.typingChatId } : {}
         };
       } finally {
         if (preparedTarget.typingChatId != null) {
           await resolved.context.client.sendTyping({ chatId: preparedTarget.typingChatId, typing: false }).catch(() => {});
+          if (!delivered) {
+            await sendInlineBotPresenceState(resolved.context.client, preparedTarget.typingChatId, BotPresenceState_Kind.IDLE);
+          }
         }
       }
     }
@@ -40542,6 +41521,9 @@ var inlineApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
           parseMarkdown: entry.parseMarkdown
         }
       });
+      if (entry.typingChatId != null) {
+        await sendInlineBotPresenceState(resolved.context.client, entry.typingChatId, BotPresenceState_Kind.IDLE);
+      }
     }
   },
   observe: {
@@ -40554,5 +41536,5 @@ export {
   inlineApprovalNativeRuntime
 };
 
-//# debugId=A870EC753942A49D64756E2164756E21
+//# debugId=E7DCFACBDA8D313664756E2164756E21
 //# sourceMappingURL=approval-handler.runtime.js.map