feat(client): sticker choosing typing event

also prettier fucked everything up, fixed that

packages/client/src/methods/bots/normalize-command-scope.ts

@@ -26,13 +26,15 @@ export async function _normalizeCommandScope(
             const user = normalizeToInputUser(await this.resolvePeer(scope.user))
 
             if (!user)
-                throw new MtInvalidPeerTypeError(scope.user, 'u"user"
+                throw new MtInvalidPeerTypeError(scope.user, 'user')
-;            return {
+
-                _: 'b"botCommandScopePeerUser"                peer: chat,
+            return {
+                _: 'botCommandScopePeerUser',
+                peer: chat,
                 userId: user
             }
- ;       }
+        }
         default:
             assertNever(scope)
- ;   }
+    }
 }

packages/client/src/methods/chats/get-chat-event-log.ts

@@ -5,7 +5,7 @@ import {
     ChatEvent, PeersIndex,
 } from '../../types'
 import { tl } from '@mtcute/tl'
-import { assertNever, MaybeArray } from '@mtcute/core'
+import { assertNever, MaybeArray } from "@mtcute/core";
 import {
     normalizeToInputChannel,
     normalizeToInputUser,
@@ -182,14 +182,17 @@ export async function* getChatEventLog(
                     case 'user_joined_invite':
                         // not documented so idk, enable all
                         serverFilter!.join = true
- ;                       serverFilter!.invite = true
+                        serverFilter!.invite = true
- ;                       serverFilter!.invites = true
+                        serverFilter!.invites = true
- ;                       break
+                        break
- ;                   case 'i"invite_deleted"                    case 'i"invite_edited"                    case 'i"invite_revoked"                        serverFilter!.invites = true
+                    case 'invite_deleted':
- ;                       break
+                    case 'invite_edited':
- ;                   default:
+                    case 'invite_revoked':
+                        serverFilter!.invites = true
+                        break
+                    default:
                         assertNever(type)
- ;               }
+                }
             })
         } else {
             serverFilter = params.filters

packages/client/src/methods/chats/get-chat-members.ts

@@ -127,15 +127,18 @@ export async function getChatMembers(
             case 'bots':
                 filter = { _: 'channelParticipantsBots' }
                 break
- ;           case 'r"recent"                filter = { _: 'c"channelParticipantsRecent"
+            case 'recent':
- ;               break
+                filter = { _: 'channelParticipantsRecent' }
- ;           case 'a"admins"                filter = { _: 'c"channelParticipantsAdmins"
+                break
- ;               break
+            case 'admins':
- ;           case 'c"contacts"                filter = { _: 'c"channelParticipantsContacts"q }
+                filter = { _: 'channelParticipantsAdmins' }
- ;               break
+                break
- ;           default:
+            case 'contacts':
+                filter = { _: 'channelParticipantsContacts', q }
+                break
+            default:
                 assertNever(type)
- ;       }
+        }
 
         const res = await this.call({
             _: 'channels.getParticipants',

packages/client/src/methods/files/upload-media.ts

@@ -80,11 +80,17 @@ export async function uploadMedia(
         case 'inputMediaPhoto':
         case 'inputMediaPhotoExternal':
             assertTypeIs('uploadMedia', res, 'messageMediaPhoto')
-            assertTypeIs('u"uploadMedia"res.photo!, 'p"photo"
+            assertTypeIs('uploadMedia', res.photo!, 'photo')
-;            return new Photo(this, res.photo)
+
- ;       case 'i"inputMediaUploadedDocument"        case 'i"inputMediaDocument"        case 'i"inputMediaDocumentExternal"            assertTypeIs('u"uploadMedia"res, 'm"messageMediaDocument" ;           assertTypeIs('u"uploadMedia"res.document!, 'd"document"
+            return new Photo(this, res.photo)
-;            return parseDocument(this, res.document) as any
+        case 'inputMediaUploadedDocument':
- ;       default:
+        case 'inputMediaDocument':
+        case 'inputMediaDocumentExternal':
+            assertTypeIs('uploadMedia', res, 'messageMediaDocument')
+            assertTypeIs('uploadMedia', res.document!, 'document')
+
+            return parseDocument(this, res.document) as any
+        default:
             assertNever(normMedia)
- ;   }
+    }
 }

packages/client/src/methods/messages/send-typing.ts

@@ -71,15 +71,21 @@ export async function sendTyping(
             case 'record_round':
                 status = { _: 'sendMessageRecordRoundAction' }
                 break
- ;           case 'u"upload_round"                status = { _: 's"sendMessageUploadRoundAction"progress }
+            case 'upload_round':
- ;               break
+                status = { _: 'sendMessageUploadRoundAction', progress }
- ;           case 's"speak_call"                status = { _: 's"speakingInGroupCallAction"
+                break
- ;               break
+            case 'speak_call':
- ;           case 'h"history_import"                status = { _: 's"sendMessageHistoryImportAction"progress }
+                status = { _: 'speakingInGroupCallAction' }
- ;               break
+                break
- ;           default:
+            case 'history_import':
+                status = { _: 'sendMessageHistoryImportAction', progress }
+                break
+            case 'sticker':
+                status = { _: 'sendMessageChooseStickerAction' }
+                break
+            default:
                 assertNever(status)
- ;       }
+        }
     }
 
     await this.call({

packages/client/src/methods/updates.ts

@@ -218,19 +218,19 @@ export async function _fetchUpdatesState(this: TelegramClient): Promise<void> {
         })
 
         switch (diff._) {
-            case"updates.differenceEmpty"':
+            case 'updates.differenceEmpty':
-                brea;k
+                break
-            case"updates.differenceTooLong"': // shouldn't happen, but who knows?
+            case 'updates.differenceTooLong': // shouldn't happen, but who knows?
-                ;(state as tl.Mutable<tl.updates.TypeState>).pts = diff.pt;s
+                ;(state as tl.Mutable<tl.updates.TypeState>).pts = diff.pts
-                brea;k
+                break
-            case"updates.differenceSlice"':
+            case 'updates.differenceSlice':
-                state = diff.intermediateStat;e
+                state = diff.intermediateState
-                brea;k
+                break
-            case"updates.difference"':
+            case 'updates.difference':
-                state = diff.stat;e
+                state = diff.state
-                brea;k
+                break
             default:
-                assertNever(diff;)
+                assertNever(diff)
         }
 
         this._qts = state.qts
@@ -1403,18 +1403,18 @@ export function _handleUpdate(
             })
             break
         case 'updates':
-        case "updatesCombined":
+        case 'updatesCombined':
             this._pendingUpdateContainers.add({
                 upd: update,
                 seqStart:
-                    update._ === "updatesCombined"
+                    update._ === 'updatesCombined'
                         ? update.seqStart
                         : update.seq,
-                seqEnd: update.seq
+                seqEnd: update.seq,
-            });
+            })
-            break;
+            break
         default:
-            assertNever(update);
+            assertNever(update)
     }
 
     this._updatesLoopCv.notify()
@@ -2259,17 +2259,17 @@ export async function _updatesLoop(this: TelegramClient): Promise<void> {
             // first process pending containers
             while (this._pendingUpdateContainers.length) {
                 const { upd, seqStart, seqEnd } =
-                    this._pendingUpdateContainers.popFront()!;
+                    this._pendingUpdateContainers.popFront()!
 
                 switch (upd._) {
-                    case "updatesTooLong":
+                    case 'updatesTooLong':
                         log.debug(
-                            "received updatesTooLong, fetching difference"
+                            'received updatesTooLong, fetching difference'
-                        );
+                        )
-                        _fetchDifferenceLater.call(this, requestedDiff);
+                        _fetchDifferenceLater.call(this, requestedDiff)
-                        break;
+                        break
-                    case "updatesCombined":
+                    case 'updatesCombined':
-                    case "updates": {
+                    case 'updates': {
                         if (seqStart !== 0) {
                             // https://t.me/tdlibchat/5843
                             const nextLocalSeq = this._seq! + 1
@@ -2452,18 +2452,18 @@ export async function _updatesLoop(this: TelegramClient): Promise<void> {
                         this._pendingPtsUpdates.add({
                             update,
                             ptsBefore: upd.pts - upd.ptsCount,
-                            pts: upd.pts
+                            pts: upd.pts,
                         })
 
-                        break;
+                        break
                     }
-                    case "updateShortSentMessage": {
+                    case 'updateShortSentMessage': {
                         // should not happen
-                        log.warn("received updateShortSentMessage");
+                        log.warn('received updateShortSentMessage')
-                        break;
+                        break
                     }
                     default:
-                        assertNever(upd);
+                        assertNever(upd)
                 }
             }
 

packages/client/src/types/bots/input/input-inline-message.ts

@@ -283,13 +283,17 @@ export namespace BotInlineMessage {
                     _: 'inputBotInlineMessageGame',
                     replyMarkup: BotKeyboard._convertToTl(obj.replyMarkup),
                 }
-            case 'c"contact"                return {
+            case 'contact':
-                    _: 'i"inputBotInlineMessageMediaContact"                    phoneNumber: obj.phone,
+                return {
+                    _: 'inputBotInlineMessageMediaContact',
+                    phoneNumber: obj.phone,
                     firstName: obj.firstName,
-                    lastName: obj.lastName ?? ''""                    vcard: obj.vcard ?? ''""                    replyMarkup: BotKeyboard._convertToTl(obj.replyMarkup),
+                    lastName: obj.lastName ?? '',
-               }
+                    vcard: obj.vcard ?? '',
- ;           default:
+                    replyMarkup: BotKeyboard._convertToTl(obj.replyMarkup),
+                }
+            default:
                 assertNever(obj)
- ;       }
+        }
     }
 }

packages/client/src/types/bots/keyboards.ts

@@ -396,14 +396,17 @@ export namespace BotKeyboard {
                 }
             case 'force_reply':
                 return {
-                    _: 'r"replyKeyboardForceReply"                    singleUse: obj.singleUse,
+                    _: 'replyKeyboardForceReply',
+                    singleUse: obj.singleUse,
                     selective: obj.selective,
-               }
+                }
- ;           case 'i"inline"                return {
+            case 'inline':
-                    _: 'r"replyInlineMarkup"                    rows: _2dToRows(obj.buttons),
+                return {
-               }
+                    _: 'replyInlineMarkup',
- ;           default:
+                    rows: _2dToRows(obj.buttons),
+                }
+            default:
                 assertNever(obj)
- ;       }
+        }
     }
 }

packages/client/src/types/calls/discard-reason.ts

@@ -15,9 +15,17 @@ export function _callDiscardReasonFromTl(
     raw: tl.TypePhoneCallDiscardReason
 ): CallDiscardReason {
     switch (raw._) {
-        case 'p"phoneCallDiscardReasonMissed"            return 'm"missed";       case 'p"phoneCallDiscardReasonDisconnect"            return 'd"disconnect";       case 'p"phoneCallDiscardReasonHangup"            return 'h"hangup";       case 'p"phoneCallDiscardReasonBusy"            return 'b"busy";       default:
+        case 'phoneCallDiscardReasonMissed':
+            return 'missed'
+        case 'phoneCallDiscardReasonDisconnect':
+            return 'disconnect'
+        case 'phoneCallDiscardReasonHangup':
+            return 'hangup'
+        case 'phoneCallDiscardReasonBusy':
+            return 'busy'
+        default:
             assertNever(raw)
- ;   }
+    }
 }
 
 /** @internal */
@@ -25,15 +33,15 @@ export function _callDiscardReasonToTl(
     r: CallDiscardReason
 ): tl.TypePhoneCallDiscardReason {
     switch (r) {
-        case "missed":
+        case 'missed':
-            return { _: "phoneCallDiscardReasonMissed" };
+            return { _: 'phoneCallDiscardReasonMissed' }
-        case "disconnect":
+        case 'disconnect':
-            return { _: "phoneCallDiscardReasonDisconnect" };
+            return { _: 'phoneCallDiscardReasonDisconnect' }
-        case "hangup":
+        case 'hangup':
-            return { _: "phoneCallDiscardReasonHangup" };
+            return { _: 'phoneCallDiscardReasonHangup' }
-        case "busy":
+        case 'busy':
-            return { _: "phoneCallDiscardReasonBusy" };
+            return { _: 'phoneCallDiscardReasonBusy' }
         default:
-            assertNever(r);
+            assertNever(r)
     }
 }

packages/client/src/types/messages/message.ts

@@ -1,8 +1,11 @@
 import { User, Chat, InputPeerLike, PeersIndex } from '../peers'
 import { tl } from '@mtcute/tl'
 import { BotKeyboard, ReplyMarkup } from '../bots'
-import { assertNever, getMarkedPeerId, toggleChannelIdMark } from '@mtcute/core'
+import { assertNever, getMarkedPeerId, toggleChannelIdMark } from "@mtcute/core";
-import { MtArgumentError, MtTypeAssertionError } from '../errors'
+import {
+    MtArgumentError,
+    MtTypeAssertionError,
+} from '../errors'
 import { TelegramClient } from '../../client'
 import { MessageEntity } from './message-entity'
 import { makeInspectable } from '../utils'

packages/client/src/types/peers/chat-event.ts

@@ -9,7 +9,7 @@ import { ChatPermissions } from './chat-permissions'
 import { ChatLocation } from './chat-location'
 import { ChatInviteLink } from './chat-invite-link'
 import { PeersIndex } from './index'
-import { toggleChannelIdMark } from '@mtcute/core'
+import { toggleChannelIdMark } from "@mtcute/core"
 
 
 export namespace ChatEvent {

packages/client/src/types/peers/typing-status.ts

@@ -19,6 +19,7 @@
  *  - `upload_round`: User is uploading a round video message
  *  - `speak_call`: *undocumented* User is speaking in a group call
  *  - `history_import`: *undocumented* User is importing history
+ *  - `sticker`: User is choosing a sticker
  */
 export type TypingStatus =
     | 'typing'
@@ -36,3 +37,4 @@ export type TypingStatus =
     | 'upload_round'
     | 'speak_call'
     | 'history_import'
+    | 'sticker'

packages/client/src/types/updates/user-typing-update.ts

@@ -99,6 +99,8 @@ export class UserTypingUpdate {
                 return 'speak_call'
             case 'sendMessageHistoryImportAction':
                 return 'history_import'
+            case 'sendMessageChooseStickerAction':
+                return 'sticker'
         }
 
         throw new MtUnsupportedError()

packages/client/src/utils/inline-utils.ts

@@ -4,8 +4,8 @@ import {
     encodeUrlSafeBase64,
     parseUrlSafeBase64,
     TlBinaryReader,
-    TlBinaryWriter,
+    TlBinaryWriter
-} from '@mtcute/core'
+} from "@mtcute/core";
 
 export function parseInlineMessageId(
     id: string
@@ -39,19 +39,19 @@ export function encodeInlineMessageId(
         case 'inputBotInlineMessageID':
             writer = TlBinaryWriter.manualAlloc(20)
             writer.int(id.dcId)
-;            writer.long(id.id)
+            writer.long(id.id)
-;            writer.long(id.accessHash)
+            writer.long(id.accessHash)
-;            break
+            break
-;        case '"inputBotInlineMessageID64"
+        case 'inputBotInlineMessageID64':
             writer = TlBinaryWriter.manualAlloc(24)
-;            writer.int(id.dcId)
+            writer.int(id.dcId)
-;            writer.long(id.ownerId)
+            writer.long(id.ownerId)
-;            writer.int(id.id)
+            writer.int(id.id)
-;            writer.long(id.accessHash)
+            writer.long(id.accessHash)
-;            break
+            break
-;        default:
+        default:
             assertNever(id)
-;    }
+    }
 
     return encodeUrlSafeBase64(writer.result())
 }

packages/client/src/utils/peer-utils.ts

@@ -35,15 +35,17 @@ export function normalizeToInputPeer(
                 channelId: res.channelId,
                 msgId: res.msgId,
                 peer: res.peer,
-           }
+            }
-        case 'i"inputUserFromMessage"            return {
+        case 'inputUserFromMessage':
-                _: 'i"inputPeerUserFromMessage"                userId: res.userId,
+            return {
+                _: 'inputPeerUserFromMessage',
+                userId: res.userId,
                 msgId: res.msgId,
                 peer: res.peer,
-           }
+            }
- ;       default:
+        default:
             assertNever(res)
- ;   }
+    }
 }
 
 export function normalizeToInputUser(

packages/dispatcher/src/state/key.ts

@@ -1,5 +1,5 @@
 import { CallbackQuery, Message } from '@mtcute/client'
-import { assertNever, MaybeAsync } from '@mtcute/core'
+import { assertNever, MaybeAsync } from "@mtcute/core";
 
 /**
  * Function that determines how the state key is derived.
@@ -29,10 +29,17 @@ export const defaultStateKeyDelegate: StateKeyDelegate = (
 ): string | null => {
     if (upd.constructor === Message) {
         switch (upd.chat.type) {
-            case 'p"private"            case 'b"bot"            case 'c"channel"                return upd.chat.id + ''"";           case 'g"group"            case 's"supergroup"            case 'g"gigagroup"                return `${upd.chat.id}_${upd.sender.id}`
+            case 'private':
- ;           default:
+            case 'bot':
+            case 'channel':
+                return upd.chat.id + ''
+            case 'group':
+            case 'supergroup':
+            case 'gigagroup':
+                return `${upd.chat.id}_${upd.sender.id}`
+            default:
                 assertNever(upd.chat.type)
- ;       }
+        }
     }
 
     if (upd.constructor === CallbackQuery) {

packages/file-id/src/convert.ts

@@ -1,7 +1,7 @@
 import { tl } from '@mtcute/tl'
 import { tdFileId, tdFileId as td } from './types'
 import { parseFileId } from './parse'
-import { assertNever, getBasicPeerType, markedPeerIdToBare } from '@mtcute/core'
+import { assertNever, getBasicPeerType, markedPeerIdToBare } from "@mtcute/core";
 import FileType = tdFileId.FileType
 import Long from 'long'
 
@@ -169,16 +169,19 @@ export function fileIdToInputFileLocation(
                         volumeId: loc.source.volumeId,
                         localId: loc.source.localId,
                     }
-                case 's"stickerSetThumbnailVersion"                    return {
+                case 'stickerSetThumbnailVersion':
-                        _: 'i"inputStickerSetThumb"                        stickerset: {
+                    return {
-                            _: 'i"inputStickerSetID"                            id: loc.source.id,
+                        _: 'inputStickerSetThumb',
+                        stickerset: {
+                            _: 'inputStickerSetID',
+                            id: loc.source.id,
                             accessHash: loc.source.accessHash,
-                       },
+                        },
                         thumbVersion: loc.source.version
                     }
- ;               default:
+                default:
                     assertNever(loc.source)
- ;           }
+            }
 
             throw new td.ConversionError('inputFileLocation')
         }
@@ -205,16 +208,16 @@ export function fileIdToInputFileLocation(
                 }
             } else {
                 return {
-                    _: "inputDocumentFileLocation",
+                    _: 'inputDocumentFileLocation',
                     fileReference: fileId.fileReference,
                     id: loc.id,
                     accessHash: loc.accessHash,
-                    thumbSize: ""
+                    thumbSize: '',
-                };
+                }
             }
         }
         default:
-            assertNever(loc);
+            assertNever(loc)
     }
 }
 

packages/file-id/src/serialize-unique.ts

@@ -1,5 +1,5 @@
 import { tdFileId, tdFileId as td } from './types'
-import { assertNever, encodeUrlSafeBase64 } from '@mtcute/core'
+import { assertNever, encodeUrlSafeBase64 } from "@mtcute/core";
 import { telegramRleEncode } from './utils'
 import FileType = tdFileId.FileType
 import { TlBinaryWriter } from '@mtcute/tl-runtime'
@@ -141,8 +141,7 @@ export function toUniqueFileId(
             break
         }
         case 'web':
-            writer = TlBinaryWriter.alloc(
+            writer = TlBinaryWriter.alloc({},
-                {},
                 Buffer.byteLength(inputLocation.url, 'utf-8') + 8
             )
             writer.int(type)

packages/file-id/src/serialize.ts

@@ -1,5 +1,5 @@
 import { tdFileId as td } from './types'
-import { assertNever, encodeUrlSafeBase64 } from '@mtcute/core'
+import { assertNever, encodeUrlSafeBase64 } from "@mtcute/core";
 import { telegramRleEncode } from './utils'
 import { TlBinaryWriter } from '@mtcute/tl-runtime'
 
@@ -86,25 +86,27 @@ export function toFileId(
                     writer.int(8)
                     writer.long(loc.source.id)
                     writer.long(loc.source.accessHash)
-  ;                  writer.long(loc.source.volumeId)
+                    writer.long(loc.source.volumeId)
-  ;                  writer.int(loc.source.localId)
+                    writer.int(loc.source.localId)
-  ;                  break
+                    break
-  ;              case 'st"stickerSetThumbnailVersion"                   writer.int(9)
+                case 'stickerSetThumbnailVersion':
-  ;                  writer.long(loc.source.id)
+                    writer.int(9)
-  ;                  writer.long(loc.source.accessHash)
+                    writer.long(loc.source.id)
-  ;                  writer.int(loc.source.version)
+                    writer.long(loc.source.accessHash)
-  ;                  break
+                    writer.int(loc.source.version)
-  ;              default:
+                    break
+                default:
                     assertNever(loc.source)
-  ;          }
+            }
 
             break
-  ;      case 'co"common"           writer.long(loc.id)
+        case 'common':
-  ;          writer.long(loc.accessHash)
+            writer.long(loc.id)
-  ;          break
+            writer.long(loc.accessHash)
-  ;      default:
+            break
+        default:
             assertNever(loc)
-  ;  }
+    }
 
     return encodeUrlSafeBase64(
         Buffer.concat([telegramRleEncode(writer.result()), SUFFIX])

packages/socks-proxy/index.ts

@@ -3,8 +3,8 @@ import {
     BaseTcpTransport,
     TransportState,
     tl,
-    assertNever,
+    assertNever
-} from '@mtcute/core'
+} from "@mtcute/core";
 import { connect } from 'net'
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
@@ -439,18 +439,17 @@ export abstract class BaseSocksTcpTransport extends BaseTcpTransport {
                                 code in SOCKS5_ERRORS
                                     ? SOCKS5_ERRORS[code]
                                     : `Unknown error code: 0x${code.toString(
-                                        16
+                                          16
-                                    )}`
+                                      )}`
                             this._socket!.emit(
-                                '"error"
+                                'error',
                                 new SocksProxyConnectionError(this._proxy, msg)
                             )
-;                        }
+                        }
                         break
-;                    }
+                    }
-                    default:
+                    default: assertNever(state)
-                        assertNever(state)
+                }
-;                }
             }
 
             this.log.debug(