@aracna/telegram-bot 1.9.13 → 1.9.14

package/builders/button.builder.d.ts

@@ -1,6 +1,6 @@
-import { InlineKeyboardButton, LoginUrl } from '@aracna/telegram-bot-types';
+import type { InlineKeyboardButton, LoginUrl } from '@aracna/telegram-bot-types';
 export declare class ButtonBuilder {
-    callback<T>(text: string, data: T, type: string, chatID?: number): InlineKeyboardButton;
+    callback<T>(text: string, data: T, type: string, chatID?: bigint): InlineKeyboardButton;
     game(text: string, game: string): InlineKeyboardButton;
     login(text: string, url: string, fields?: Partial<LoginUrl>): InlineKeyboardButton;
     pay(text: string): InlineKeyboardButton;

package/childs/add.d.ts

@@ -1,6 +1,6 @@
-import { FetchError } from '@aracna/core';
-import { AddStickerToSet, InputSticker, Message } from '@aracna/telegram-bot-types';
+import type { FetchError } from '@aracna/core';
+import type { AddStickerToSet, InputSticker, Message } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Add extends Child {
-    stickerToSet(userID: number, name: string, sticker: InputSticker, parameters: Partial<AddStickerToSet>): Promise<Message | FetchError>;
+    stickerToSet(userID: bigint, name: string, sticker: InputSticker, parameters?: Partial<AddStickerToSet>): Promise<Message | FetchError>;
 }

package/childs/answer.d.ts

@@ -1,9 +1,10 @@
-import { FetchError } from '@aracna/core';
-import { AnswerCallbackQuery, AnswerInlineQuery, AnswerPreCheckoutQuery, AnswerShippingQuery, InlineQueryResult } from '@aracna/telegram-bot-types';
+import type { FetchError } from '@aracna/core';
+import type { AnswerCallbackQuery, AnswerInlineQuery, AnswerPreCheckoutQuery, AnswerShippingQuery, AnswerWebAppQuery, InlineQueryResult, SentWebAppMessage } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Answer extends Child {
     callbackQuery(id: string, parameters?: Partial<AnswerCallbackQuery>): Promise<boolean | FetchError>;
     inlineQuery(id: string, results: InlineQueryResult[], parameters?: Partial<AnswerInlineQuery>): Promise<boolean | FetchError>;
     preCheckoutQuery(id: string, ok: boolean, parameters?: Partial<AnswerPreCheckoutQuery>): Promise<boolean | FetchError>;
     shippingQuery(id: string, ok: boolean, parameters?: Partial<AnswerShippingQuery>): Promise<boolean | FetchError>;
+    webAppQuery(id: string, result: InlineQueryResult, parameters?: Partial<AnswerWebAppQuery>): Promise<SentWebAppMessage | FetchError>;
 }

package/childs/answer.js

@@ -15,5 +15,8 @@ class Answer extends child_1.Child {
     async shippingQuery(id, ok, parameters) {
         return this.telegram.api.post('answerShippingQuery', { ok: ok, shipping_query_id: id, ...parameters });
     }
+    async webAppQuery(id, result, parameters) {
+        return this.telegram.api.post('answerWebAppQuery', { result: result, web_app_query_id: id, ...parameters });
+    }
 }
 exports.Answer = Answer;

package/childs/approve.d.ts

@@ -0,0 +1,6 @@
+import type { FetchError } from '@aracna/core';
+import type { ApproveChatJoinRequest } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Approve extends Child {
+    chatJoinRequest(parameters: ApproveChatJoinRequest): Promise<boolean | FetchError>;
+}

package/childs/approve.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Approve = void 0;
+const child_1 = require("../modules/child");
+class Approve extends child_1.Child {
+    async chatJoinRequest(parameters) {
+        return this.telegram.api.post('approveChatJoinRequest', parameters);
+    }
+}
+exports.Approve = Approve;

package/childs/ban.d.ts

@@ -1,6 +1,7 @@
-import { FetchError } from '@aracna/core';
-import { BanChatMember } from '@aracna/telegram-bot-types';
+import type { FetchError } from '@aracna/core';
+import type { BanChatMember, BanChatSenderChat } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Ban extends Child {
-    chatMember(chatID: number, userID: number, parameters?: Partial<BanChatMember>): Promise<boolean | FetchError>;
+    chatMember(parameters: BanChatMember): Promise<boolean | FetchError>;
+    chatSenderChat(parameters: BanChatSenderChat): Promise<boolean | FetchError>;
 }

package/childs/ban.js

@@ -3,8 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ban = void 0;
 const child_1 = require("../modules/child");
 class Ban extends child_1.Child {
-    async chatMember(chatID, userID, parameters) {
-        return this.telegram.api.post('banChatMember', { chat_id: chatID, user_id: userID, ...parameters });
+    async chatMember(parameters) {
+        return this.telegram.api.post('banChatMember', parameters);
+    }
+    async chatSenderChat(parameters) {
+        return this.telegram.api.post('banChatSenderChat', parameters);
     }
 }
 exports.Ban = Ban;

package/childs/close.d.ts

@@ -0,0 +1,7 @@
+import type { FetchError } from '@aracna/core';
+import type { CloseForumTopic, CloseGeneralForumTopic } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Close extends Child {
+    forumTopic(chatID: bigint, messageThreadID: number, parameters?: Partial<CloseForumTopic>): Promise<boolean | FetchError>;
+    generalForumTopic(chatID: bigint, parameters?: Partial<CloseGeneralForumTopic>): Promise<boolean | FetchError>;
+}

package/childs/close.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Close = void 0;
+const child_1 = require("../modules/child");
+class Close extends child_1.Child {
+    async forumTopic(chatID, messageThreadID, parameters) {
+        return this.telegram.api.post('closeForumTopic', { chat_id: chatID, message_thread_id: messageThreadID, ...parameters });
+    }
+    async generalForumTopic(chatID, parameters) {
+        return this.telegram.api.post('closeGeneralForumTopic', { chat_id: chatID, ...parameters });
+    }
+}
+exports.Close = Close;

package/childs/copy.d.ts

@@ -0,0 +1,7 @@
+import type { FetchError } from '@aracna/core';
+import type { CopyMessage, CopyMessages, MessageId } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Copy extends Child {
+    message(messageID: number, parameters: Omit<CopyMessage, 'message_id'>): Promise<MessageId | FetchError>;
+    messages(messageIDs: number[], parameters: Omit<CopyMessages, 'message_ids'>): Promise<MessageId[] | FetchError>;
+}

package/childs/copy.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Copy = void 0;
+const child_1 = require("../modules/child");
+class Copy extends child_1.Child {
+    async message(messageID, parameters) {
+        return this.telegram.api.post('copyMessage', { message_id: messageID, ...parameters });
+    }
+    async messages(messageIDs, parameters) {
+        return this.telegram.api.post('copyMessages', { message_ids: messageIDs, ...parameters });
+    }
+}
+exports.Copy = Copy;

package/childs/create.d.ts

@@ -1,6 +1,10 @@
-import { FetchError } from '@aracna/core';
-import { CreateNewStickerSet, InputSticker } from '@aracna/telegram-bot-types';
+import type { FetchError } from '@aracna/core';
+import type { ChatInviteLink, CreateChatInviteLink, CreateChatSubscriptionInviteLink, CreateForumTopic, CreateInvoiceLink, CreateNewStickerSet, InputSticker, LabeledPrice } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Create extends Child {
-    stickerSet(userID: number, type: string, name: string, title: string, stickers: InputSticker[], parameters: Partial<CreateNewStickerSet>): Promise<boolean | FetchError>;
+    chatInviteLink(chatID: bigint, parameters?: Partial<CreateChatInviteLink>): Promise<ChatInviteLink | FetchError>;
+    chatSubscriptionInviteLink(chatID: bigint, parameters: Omit<CreateChatSubscriptionInviteLink, 'chat_id'>): Promise<ChatInviteLink | FetchError>;
+    forumTopic(chatID: bigint, name: string, parameters?: Partial<CreateForumTopic>): Promise<boolean | FetchError<undefined>>;
+    invoiceLink(prices: LabeledPrice[], parameters: Omit<CreateInvoiceLink, 'prices'>): Promise<string | FetchError>;
+    stickerSet(userID: bigint, stickers: InputSticker[], parameters: Omit<CreateNewStickerSet, 'stickers' | 'user_id'>): Promise<boolean | FetchError>;
 }

package/childs/create.js

@@ -3,12 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Create = void 0;
 const child_1 = require("../modules/child");
 class Create extends child_1.Child {
-    async stickerSet(userID, type, name, title, stickers, parameters) {
+    async chatInviteLink(chatID, parameters) {
+        return this.telegram.api.post('createChatInviteLink', { chat_id: chatID, ...parameters });
+    }
+    async chatSubscriptionInviteLink(chatID, parameters) {
+        return this.telegram.api.post('createChatSubscriptionInviteLink', { chat_id: chatID, ...parameters });
+    }
+    async forumTopic(chatID, name, parameters) {
+        return this.telegram.api.post('createForumTopic', { chat_id: chatID, name: name, ...parameters });
+    }
+    async invoiceLink(prices, parameters) {
+        return this.telegram.api.post('createInvoiceLink', { prices: prices, ...parameters });
+    }
+    async stickerSet(userID, stickers, parameters) {
         return this.telegram.api.post('createNewStickerSet', {
-            name: name,
-            sticker_type: type,
             stickers: stickers,
-            title: title,
             user_id: userID,
             ...parameters
         });

package/childs/decline.d.ts

@@ -0,0 +1,6 @@
+import type { FetchError } from '@aracna/core';
+import type { DeclineChatJoinRequest } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Decline extends Child {
+    chatJoinRequest(parameters: DeclineChatJoinRequest): Promise<boolean | FetchError>;
+}

package/childs/decline.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decline = void 0;
+const child_1 = require("../modules/child");
+class Decline extends child_1.Child {
+    async chatJoinRequest(parameters) {
+        return this.telegram.api.post('declineChatJoinRequest', parameters);
+    }
+}
+exports.Decline = Decline;

package/childs/delete.d.ts

@@ -1,8 +1,13 @@
-import { FetchError } from '@aracna/core';
+import type { FetchError } from '@aracna/core';
+import type { DeleteChatPhoto, DeleteChatStickerSet, DeleteForumTopic, DeleteMessage, DeleteMessages, DeleteMyCommands, DeleteStickerFromSet, DeleteStickerSet } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Delete extends Child {
-    chatPhoto(chatID: number): Promise<boolean | FetchError>;
-    chatStickerSet(chatID: number): Promise<boolean | FetchError>;
-    message(chatID: number, message: number): Promise<boolean | FetchError>;
-    stickerFromSet(sticker: string): Promise<boolean | FetchError>;
+    chatPhoto(chatID: bigint, parameters?: Partial<DeleteChatPhoto>): Promise<boolean | FetchError>;
+    chatStickerSet(chatID: bigint, parameters?: Partial<DeleteChatStickerSet>): Promise<boolean | FetchError>;
+    commands(parameters?: Partial<DeleteMyCommands>): Promise<boolean | FetchError>;
+    forumTopic(chatID: bigint, messageThreadID: number, parameters?: Partial<DeleteForumTopic>): Promise<boolean | FetchError>;
+    message(chatID: bigint, messageID: number, parameters?: Partial<DeleteMessage>): Promise<boolean | FetchError>;
+    messages(chatID: bigint, messageIDs: number[], parameters?: Partial<DeleteMessages>): Promise<boolean | FetchError>;
+    stickerFromSet(sticker: string, parameters?: Partial<DeleteStickerFromSet>): Promise<boolean | FetchError>;
+    stickerSet(name: string, parameters?: Partial<DeleteStickerSet>): Promise<boolean | FetchError>;
 }

package/childs/delete.js

@@ -3,17 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Delete = void 0;
 const child_1 = require("../modules/child");
 class Delete extends child_1.Child {
-    async chatPhoto(chatID) {
-        return this.telegram.api.post('deleteChatPhoto', { chat_id: chatID });
+    async chatPhoto(chatID, parameters) {
+        return this.telegram.api.post('deleteChatPhoto', { chat_id: chatID, ...parameters });
     }
-    async chatStickerSet(chatID) {
-        return this.telegram.api.post('deleteChatStickerSet', { chat_id: chatID });
+    async chatStickerSet(chatID, parameters) {
+        return this.telegram.api.post('deleteChatStickerSet', { chat_id: chatID, ...parameters });
     }
-    async message(chatID, message) {
-        return this.telegram.api.post('deleteMessage', { chat_id: chatID, message_id: message });
+    async commands(parameters) {
+        return this.telegram.api.post('deleteMyCommands', parameters);
     }
-    async stickerFromSet(sticker) {
-        return this.telegram.api.post('deleteStickerFromSet', { sticker: sticker });
+    async forumTopic(chatID, messageThreadID, parameters) {
+        return this.telegram.api.post('deleteForumTopic', { chat_id: chatID, message_thread_id: messageThreadID, ...parameters });
+    }
+    async message(chatID, messageID, parameters) {
+        return this.telegram.api.post('deleteMessage', { chat_id: chatID, message_id: messageID, ...parameters });
+    }
+    async messages(chatID, messageIDs, parameters) {
+        return this.telegram.api.post('deleteMessages', { chat_id: chatID, message_ids: messageIDs, ...parameters });
+    }
+    async stickerFromSet(sticker, parameters) {
+        return this.telegram.api.post('deleteStickerFromSet', { sticker: sticker, ...parameters });
+    }
+    async stickerSet(name, parameters) {
+        return this.telegram.api.post('deleteChatStickerSet', { name: name, ...parameters });
     }
 }
 exports.Delete = Delete;

package/childs/download.d.ts

@@ -1,8 +1,8 @@
-import { FetchError } from '@aracna/core';
+import type { FetchError } from '@aracna/core';
 import { API } from '../modules/api';
 import { Child } from '../modules/child';
 export declare class Download extends Child {
     api: API;
     file(id: string): Promise<Buffer | FetchError>;
-    userFirstProfilePhoto(id: number): Promise<Buffer | FetchError | Error>;
+    userFirstProfilePhoto(id: bigint): Promise<Buffer | FetchError | Error>;
 }

package/childs/edit.d.ts

@@ -1,10 +1,14 @@
-import { FetchError } from '@aracna/core';
-import { EditMessageCaption, EditMessageLiveLocation, EditMessageMedia, EditMessageReplyMarkup, EditMessageText, InputMedia, Message } from '@aracna/telegram-bot-types';
+import type { FetchError } from '@aracna/core';
+import type { ChatInviteLink, EditChatInviteLink, EditChatSubscriptionInviteLink, EditForumTopic, EditGeneralForumTopic, EditMessageCaption, EditMessageLiveLocation, EditMessageMedia, EditMessageReplyMarkup, EditMessageText, InputMedia, Message } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Edit extends Child {
+    chatInviteLink(chatID: bigint, inviteLink: string, parameters?: Partial<EditChatInviteLink>): Promise<ChatInviteLink | FetchError>;
+    chatSubscriptionInviteLInk(chatID: bigint, inviteLink: string, parameters?: Partial<EditChatSubscriptionInviteLink>): Promise<ChatInviteLink | FetchError>;
+    forumTopic(chatID: bigint, messageThreadID: number, parameters?: Partial<EditForumTopic>): Promise<boolean | FetchError>;
+    generalForumTopic(chatID: bigint, name: string, parameters?: Partial<EditGeneralForumTopic>): Promise<boolean | FetchError>;
     messageCaption(parameters: EditMessageCaption): Promise<Message | FetchError>;
-    messageLiveLocation(latitude: number, longitude: number, parameters: Partial<EditMessageLiveLocation>): Promise<Message | FetchError>;
-    messageMedia(media: InputMedia, parameters: Partial<EditMessageMedia>): Promise<Message | FetchError>;
+    messageLiveLocation(parameters: EditMessageLiveLocation): Promise<Message | FetchError>;
+    messageMedia(media: InputMedia, parameters?: Partial<EditMessageMedia>): Promise<Message | FetchError>;
     messageReplyMarkup(parameters: EditMessageReplyMarkup): Promise<Message | FetchError>;
-    messageText(text: string, parameters: Partial<EditMessageText>): Promise<Message | FetchError>;
+    messageText(text: string, parameters?: Partial<EditMessageText>): Promise<Message | FetchError>;
 }

package/childs/edit.js

@@ -3,14 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Edit = void 0;
 const child_1 = require("../modules/child");
 class Edit extends child_1.Child {
+    async chatInviteLink(chatID, inviteLink, parameters) {
+        return this.telegram.api.post('editChatInviteLink', { chat_id: chatID, invite_link: inviteLink, ...parameters });
+    }
+    async chatSubscriptionInviteLInk(chatID, inviteLink, parameters) {
+        return this.telegram.api.post('editChatSubscriptionInviteLink', {
+            chat_id: chatID,
+            invite_link: inviteLink,
+            ...parameters
+        });
+    }
+    async forumTopic(chatID, messageThreadID, parameters) {
+        return this.telegram.api.post('editForumTopic', { chat_id: chatID, message_thread_id: messageThreadID, ...parameters });
+    }
+    async generalForumTopic(chatID, name, parameters) {
+        return this.telegram.api.post('editGeneralForumTopic', { chat_id: chatID, name: name, ...parameters });
+    }
     async messageCaption(parameters) {
         return this.telegram.api.post('editMessageCaption', parameters);
     }
-    async messageLiveLocation(latitude, longitude, parameters) {
-        return this.telegram.api.post('editMessageLiveLocation', { latitude: latitude, longitude: longitude, ...parameters });
+    async messageLiveLocation(parameters) {
+        return this.telegram.api.post('editMessageLiveLocation', parameters);
     }
     async messageMedia(media, parameters) {
-        return this.telegram.api.post('editMessageText', { media: media, ...parameters });
+        return this.telegram.api.post('editMessageMedia', { media: media, ...parameters });
     }
     async messageReplyMarkup(parameters) {
         return this.telegram.api.post('editMessageReplyMarkup', parameters);

package/childs/export.d.ts

@@ -1,5 +1,6 @@
-import { FetchError } from '@aracna/core';
+import type { FetchError } from '@aracna/core';
+import type { ExportChatInviteLink } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Export extends Child {
-    chatInviteLink(chatID: number): Promise<string | FetchError>;
+    chatInviteLink(chatID: bigint, parameters?: Partial<ExportChatInviteLink>): Promise<string | FetchError>;
 }

package/childs/export.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Export = void 0;
 const child_1 = require("../modules/child");
 class Export extends child_1.Child {
-    async chatInviteLink(chatID) {
-        return this.telegram.api.post('exportChatInviteLink', { chat_id: chatID });
+    async chatInviteLink(chatID, parameters) {
+        return this.telegram.api.post('exportChatInviteLink', { chat_id: chatID, ...parameters });
     }
 }
 exports.Export = Export;

package/childs/forward.d.ts

@@ -1,6 +1,7 @@
-import { FetchError } from '@aracna/core';
-import { ForwardMessage, Message } from '@aracna/telegram-bot-types';
+import type { FetchError } from '@aracna/core';
+import type { ForwardMessage, ForwardMessages, Message, MessageId } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Forward extends Child {
-    message(chatID: number, fromChatID: number, messageID: number, parameters?: Partial<ForwardMessage>): Promise<Message | FetchError>;
+    message(messageID: number, parameters: Omit<ForwardMessage, 'message_id'>): Promise<Message | FetchError>;
+    messages(messageIDs: number[], parameters: Omit<ForwardMessages, 'message_ids'>): Promise<MessageId[] | FetchError>;
 }

package/childs/forward.js

@@ -3,13 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Forward = void 0;
 const child_1 = require("../modules/child");
 class Forward extends child_1.Child {
-    async message(chatID, fromChatID, messageID, parameters) {
-        return this.telegram.api.post('forwardMessage', {
-            chat_id: chatID,
-            from_chat_id: fromChatID,
-            message_id: messageID,
-            ...parameters
-        });
+    async message(messageID, parameters) {
+        return this.telegram.api.post('forwardMessage', { message_id: messageID, ...parameters });
+    }
+    async messages(messageIDs, parameters) {
+        return this.telegram.api.post('forwardMessages', { message_ids: messageIDs, ...parameters });
     }
 }
 exports.Forward = Forward;

package/childs/get.d.ts

@@ -1,15 +1,26 @@
-import { FetchError } from '@aracna/core';
-import { BotCommand, Chat, ChatMember, File, GameHighScore, GetGameHighScores, GetUserProfilePhotos, StickerSet, User, UserProfilePhotos } from '@aracna/telegram-bot-types';
+import type { FetchError } from '@aracna/core';
+import type { BotCommand, BotDescription, BotName, BotShortDescription, BusinessConnection, Chat, ChatAdministratorRights, ChatMember, File, GameHighScore, GetBusinessConnection, GetChat, GetChatAdministrators, GetChatMember, GetChatMemberCount, GetChatMenuButton, GetCustomEmojiStickers, GetFile, GetGameHighScores, GetMyCommands, GetMyDefaultAdministratorRights, GetMyDescription, GetMyName, GetMyShortDescription, GetStarTransactions, GetStickerSet, GetUpdates, GetUserChatBoosts, GetUserProfilePhotos, MenuButton, StarTransactions, Sticker, StickerSet, Update, User, UserChatBoosts, UserProfilePhotos } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Get extends Child {
-    chat(id: number): Promise<Chat | FetchError>;
-    chatAdministrators(id: number): Promise<ChatMember[] | FetchError>;
-    chatMember(chatID: number, userID: number): Promise<ChatMember | FetchError>;
-    chatMemberCount(id: number): Promise<number | FetchError>;
-    commands(): Promise<BotCommand[] | FetchError>;
-    file(id: string): Promise<File | FetchError>;
-    gameHighScores(userID: number, parameters?: Partial<GetGameHighScores>): Promise<GameHighScore | FetchError>;
+    businessConnection(businessConnectionID: string, parameters?: Partial<GetBusinessConnection>): Promise<BusinessConnection | FetchError>;
+    chat(chatID: bigint, parameters?: Partial<GetChat>): Promise<Chat | FetchError>;
+    chatAdministrators(chatID: bigint, parameters?: Partial<GetChatAdministrators>): Promise<ChatMember[] | FetchError>;
+    chatMember(parameters: GetChatMember): Promise<ChatMember | FetchError>;
+    chatMemberCount(chatID: bigint, parameters?: Partial<GetChatMemberCount>): Promise<bigint | FetchError>;
+    chatMenuButton(chatID: bigint, parameters?: Partial<GetChatMenuButton>): Promise<MenuButton | FetchError>;
+    commands(parameters?: Partial<GetMyCommands>): Promise<BotCommand[] | FetchError>;
+    customEmojiStickers(customEmojiIDs: string[], parameters?: Partial<GetCustomEmojiStickers>): Promise<Sticker[] | FetchError>;
+    defaultAdministratorRights(parameters?: Partial<GetMyDefaultAdministratorRights>): Promise<ChatAdministratorRights | FetchError>;
+    description(parameters?: Partial<GetMyDescription>): Promise<BotDescription | FetchError>;
+    file(fileID: string, parameters?: Partial<GetFile>): Promise<File | FetchError>;
+    forumTopicIconStickers(): Promise<Sticker[] | FetchError>;
+    gameHighScores(userID: bigint, parameters?: Partial<GetGameHighScores>): Promise<GameHighScore | FetchError>;
     me(): Promise<User | FetchError>;
-    stickerSet(name: string): Promise<StickerSet | FetchError>;
-    userProfilePhotos(id: number, parameters?: Partial<GetUserProfilePhotos>): Promise<UserProfilePhotos | FetchError>;
+    name(parameters?: Partial<GetMyName>): Promise<BotName | FetchError>;
+    shortDescription(parameters?: Partial<GetMyShortDescription>): Promise<BotShortDescription | FetchError>;
+    starTransactions(parameters?: Partial<GetStarTransactions>): Promise<StarTransactions | FetchError>;
+    stickerSet(name: string, parameters?: Partial<GetStickerSet>): Promise<StickerSet | FetchError>;
+    updates(parameters?: Partial<GetUpdates>): Promise<Update[] | FetchError>;
+    userChatBoosts(parameters: GetUserChatBoosts): Promise<UserChatBoosts | FetchError>;
+    userProfilePhotos(userID: bigint, parameters?: Partial<GetUserProfilePhotos>): Promise<UserProfilePhotos | FetchError>;
 }

package/childs/get.js

@@ -3,23 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Get = void 0;
 const child_1 = require("../modules/child");
 class Get extends child_1.Child {
-    async chat(id) {
-        return this.telegram.api.post('getChat', { chat_id: id });
+    async businessConnection(businessConnectionID, parameters) {
+        return this.telegram.api.post('getBusinessConnection', {
+            business_connection_id: businessConnectionID,
+            ...parameters
+        });
     }
-    async chatAdministrators(id) {
-        return this.telegram.api.post('getChatAdministrators', { chat_id: id });
+    async chat(chatID, parameters) {
+        return this.telegram.api.post('getChat', { chat_id: chatID, ...parameters });
     }
-    async chatMember(chatID, userID) {
-        return this.telegram.api.post('getChatMember', { chat_id: chatID, user_id: userID });
+    async chatAdministrators(chatID, parameters) {
+        return this.telegram.api.post('getChatAdministrators', { chat_id: chatID, ...parameters });
     }
-    async chatMemberCount(id) {
-        return this.telegram.api.post('getChatMemberCount', { chat_id: id });
+    async chatMember(parameters) {
+        return this.telegram.api.post('getChatMember', parameters);
     }
-    async commands() {
-        return this.telegram.api.post('getMyCommands');
+    async chatMemberCount(chatID, parameters) {
+        return this.telegram.api.post('getChatMemberCount', { chat_id: chatID, ...parameters });
     }
-    async file(id) {
-        return this.telegram.api.post('getFile', { file_id: id });
+    async chatMenuButton(chatID, parameters) {
+        return this.telegram.api.post('getChatMenuButton', { chat_id: chatID, ...parameters });
+    }
+    async commands(parameters) {
+        return this.telegram.api.post('getMyCommands', parameters);
+    }
+    async customEmojiStickers(customEmojiIDs, parameters) {
+        return this.telegram.api.post('getCustomEmojiStickers', { custom_emoji_ids: customEmojiIDs, ...parameters });
+    }
+    async defaultAdministratorRights(parameters) {
+        return this.telegram.api.post('getMyDefaultAdministratorRights', parameters);
+    }
+    async description(parameters) {
+        return this.telegram.api.post('getMyDescription', parameters);
+    }
+    async file(fileID, parameters) {
+        return this.telegram.api.post('getFile', { file_id: fileID, ...parameters });
+    }
+    async forumTopicIconStickers() {
+        return this.telegram.api.post('getForumTopicIconStickers');
     }
     async gameHighScores(userID, parameters) {
         return this.telegram.api.post('getGameHighScores', { user_id: userID, ...parameters });
@@ -27,11 +48,26 @@ class Get extends child_1.Child {
     async me() {
         return this.telegram.api.post('getMe');
     }
-    async stickerSet(name) {
-        return this.telegram.api.post('getStickerSet', { name: name });
+    async name(parameters) {
+        return this.telegram.api.post('getMyName', parameters);
+    }
+    async shortDescription(parameters) {
+        return this.telegram.api.post('getMyShortDescription', parameters);
+    }
+    async starTransactions(parameters) {
+        return this.telegram.api.post('getStarTransactions', parameters);
+    }
+    async stickerSet(name, parameters) {
+        return this.telegram.api.post('getStickerSet', { name: name, ...parameters });
+    }
+    async updates(parameters) {
+        return this.telegram.api.post('getUpdates', parameters);
+    }
+    async userChatBoosts(parameters) {
+        return this.telegram.api.post('getUserChatBoosts', parameters);
     }
-    async userProfilePhotos(id, parameters) {
-        return this.telegram.api.post('getUserProfilePhotos', { user_id: id, ...parameters });
+    async userProfilePhotos(userID, parameters) {
+        return this.telegram.api.post('getUserProfilePhotos', { user_id: userID, ...parameters });
     }
 }
 exports.Get = Get;

package/childs/hide.d.ts

@@ -0,0 +1,6 @@
+import type { FetchError } from '@aracna/core';
+import type { HideGeneralForumTopic } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Hide extends Child {
+    generalForumTopic(chatID: bigint, parameters?: Partial<HideGeneralForumTopic>): Promise<boolean | FetchError>;
+}

package/childs/hide.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hide = void 0;
+const child_1 = require("../modules/child");
+class Hide extends child_1.Child {
+    async generalForumTopic(chatID, parameters) {
+        return this.telegram.api.post('hideGeneralForumTopic', { chat_id: chatID, ...parameters });
+    }
+}
+exports.Hide = Hide;

package/childs/leave.d.ts

@@ -1,5 +1,6 @@
-import { FetchError } from '@aracna/core';
+import type { FetchError } from '@aracna/core';
+import type { LeaveChat } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Leave extends Child {
-    chat(id: number): Promise<boolean | FetchError>;
+    chat(chatID: bigint, parameters?: Partial<LeaveChat>): Promise<boolean | FetchError>;
 }

package/childs/leave.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Leave = void 0;
 const child_1 = require("../modules/child");
 class Leave extends child_1.Child {
-    async chat(id) {
-        return this.telegram.api.post('leaveChat', { chat_id: id });
+    async chat(chatID, parameters) {
+        return this.telegram.api.post('leaveChat', { chat_id: chatID, ...parameters });
     }
 }
 exports.Leave = Leave;

package/childs/log.d.ts

@@ -0,0 +1,5 @@
+import type { FetchError } from '@aracna/core';
+import { Child } from '../modules/child';
+export declare class Log extends Child {
+    out(): Promise<boolean | FetchError>;
+}

package/childs/log.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const child_1 = require("../modules/child");
+class Log extends child_1.Child {
+    async out() {
+        return this.telegram.api.post('logOut');
+    }
+}
+exports.Log = Log;

package/childs/pin.d.ts

@@ -1,6 +1,6 @@
-import { FetchError } from '@aracna/core';
-import { PinChatMessage } from '@aracna/telegram-bot-types';
+import type { FetchError } from '@aracna/core';
+import type { PinChatMessage } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Pin extends Child {
-    chatMessage(chatID: number, message: number, parameters?: Partial<PinChatMessage>): Promise<boolean | FetchError>;
+    chatMessage(chatID: bigint, messageID: number, parameters?: Partial<PinChatMessage>): Promise<boolean | FetchError>;
 }

package/childs/pin.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pin = void 0;
 const child_1 = require("../modules/child");
 class Pin extends child_1.Child {
-    async chatMessage(chatID, message, parameters) {
-        return this.telegram.api.post('pinChatMessage', { chat_id: chatID, message_id: message, ...parameters });
+    async chatMessage(chatID, messageID, parameters) {
+        return this.telegram.api.post('pinChatMessage', { chat_id: chatID, message_id: messageID, ...parameters });
     }
 }
 exports.Pin = Pin;

package/childs/polling.d.ts

@@ -1,4 +1,4 @@
-import { GetUpdates } from '@aracna/telegram-bot-types';
+import type { GetUpdates } from '@aracna/telegram-bot-types';
 import { Child } from '../modules/child';
 export declare class Polling extends Child {
     active: boolean;

package/childs/polling.js

@@ -20,7 +20,7 @@ class Polling extends child_1.Child {
             offset: this.offset,
             ...parameters
         };
-        updates = await this.telegram.api.post('getUpdates', body);
+        updates = await this.telegram.get.updates(parameters);
         if (updates instanceof Error)
             return updates;
         updates.forEach((v) => this.telegram.handle(v));