maxbot-api-client-ts 1.0.0

package/dist/api.js

@@ -0,0 +1,884 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/api/api.ts
+var api_exports = {};
+__export(api_exports, {
+  MaxBotAPI: () => MaxBotAPI
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/models/const.ts
+var Defaultbase_url = "https://platform-api.max.ru";
+var Paths = {
+  Me: "me",
+  Chats: "chats",
+  Answers: "answers",
+  Updates: "updates",
+  Uploads: "uploads",
+  Messages: "messages",
+  Subscriptions: "subscriptions",
+  Videos: "videos"
+};
+
+// src/client/client.ts
+var RateLimiter = class {
+  constructor(rps) {
+    this.queue = [];
+    this.timeoutId = null;
+    this.rps = rps;
+    this.tokens = rps;
+    this.lastRefill = Date.now();
+  }
+  wait() {
+    return __async(this, null, function* () {
+      return new Promise((resolve) => {
+        this.queue.push(resolve);
+        this.processQueue();
+      });
+    });
+  }
+  processQueue() {
+    const now = Date.now();
+    const timePassed = now - this.lastRefill;
+    this.tokens += timePassed * (this.rps / 1e3);
+    if (this.tokens > this.rps) {
+      this.tokens = this.rps;
+    }
+    this.lastRefill = now;
+    while (this.queue.length > 0 && this.tokens >= 1) {
+      this.tokens -= 1;
+      const resolve = this.queue.shift();
+      if (resolve) resolve();
+    }
+    if (this.queue.length > 0 && !this.timeoutId) {
+      const timeToNextToken = Math.ceil(1 / this.rps * 1e3);
+      this.timeoutId = setTimeout(() => {
+        this.timeoutId = null;
+        this.processQueue();
+      }, timeToNextToken);
+    }
+  }
+  setLimit(rps) {
+    this.rps = rps;
+    this.tokens = rps;
+  }
+};
+var APIClient = class {
+  constructor(cfg) {
+    if (!cfg.token) {
+      throw new Error("Token is not set");
+    }
+    this.base_url = cfg.base_url || Defaultbase_url;
+    this.token = cfg.token;
+    this.timeout = cfg.timeout || 35e3;
+    const rps = cfg.globalRPS && cfg.globalRPS > 0 ? cfg.globalRPS : 25;
+    this.rateLimiter = new RateLimiter(rps);
+  }
+  request(_0, _1) {
+    return __async(this, arguments, function* (method, path, opts = {}) {
+      let urlObj;
+      if (path.startsWith("http://") || path.startsWith("https://")) {
+        urlObj = new URL(path);
+      } else {
+        urlObj = new URL(path, this.base_url);
+      }
+      if (opts.query) {
+        Object.entries(opts.query).forEach(([key, value]) => {
+          if (value !== void 0 && value !== null) {
+            if (Array.isArray(value)) {
+              value.forEach((v) => urlObj.searchParams.append(key, String(v)));
+            } else {
+              urlObj.searchParams.set(key, String(value));
+            }
+          }
+        });
+      }
+      const headers = __spreadValues({
+        "Authorization": this.token
+      }, opts.headers);
+      let body = opts.body;
+      if (opts.payload && !body) {
+        body = JSON.stringify(opts.payload);
+        headers["Content-Type"] = "application/json";
+      } else if (!headers["Content-Type"] && !opts.body) {
+        headers["Content-Type"] = "application/json";
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        yield this.rateLimiter.wait();
+        const response = yield fetch(urlObj.toString(), {
+          method,
+          headers,
+          body,
+          signal: controller.signal
+        });
+        const text = yield response.text();
+        if (!response.ok) {
+          throw new Error(`[${method} ${urlObj.pathname}] HTTP ${response.status}: ${text}`);
+        }
+        if (!text) {
+          return {};
+        }
+        return JSON.parse(text);
+      } catch (error) {
+        throw error;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    });
+  }
+  setGlobalRateLimit(rps) {
+    this.rateLimiter.setLimit(rps);
+  }
+  getTimeout() {
+    return this.timeout;
+  }
+};
+
+// src/api/bots.ts
+var BotsService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * GetBot returns information about the current bot (ID, name, description).
+   * @returns Promise<BotInfo>
+   * @example
+   * const response = await bot.bots.getBot();
+   * console.log("Connected as:", info.first_name);
+   */
+  getBot() {
+    return __async(this, null, function* () {
+      return this.client.request("GET", Paths.Me);
+    });
+  }
+  /**
+   * PatchBot updates bot information.
+   * Fill in only the fields you want to change.
+   * @param req - The bot data to update.
+   * @returns Promise<BotInfo>
+   * @example
+   * const response = await bot.bots.patchBot({
+   * name: "New Name",
+   * description: "New description"
+   * });
+   */
+  patchBot(req) {
+    return __async(this, null, function* () {
+      return this.client.request("PATCH", Paths.Me, { payload: req });
+    });
+  }
+};
+
+// src/api/chats.ts
+var ChatsService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * GetChats returns a list of group chats in which the bot participated.
+   * @param req - Filter parameters for chats.
+   * @example
+   * const response = await bot.chats.getChats({ limit: 10 });
+   */
+  getChats(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", Paths.Chats, {
+        query: req
+      });
+    });
+  }
+  /**
+   * GetChat returns information about a group chat by its ID.
+   * @param req - Object containing the chat_id.
+   * @example
+   * const response = await bot.chats.getChat({ chat_id: 123456789 });
+   */
+  getChat(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", `${Paths.Chats}/${req.chat_id}`);
+    });
+  }
+  /**
+   * EditChat allows you to edit information about a group chat.
+   * @param req - Chat edit parameters.
+   * @example
+   * await bot.chats.editChat({ chat_id: 123456789, title: "New Title" });
+   */
+  editChat(req) {
+    return __async(this, null, function* () {
+      return this.client.request("PATCH", `${Paths.Chats}/${req.chat_id}`, {
+        payload: req
+      });
+    });
+  }
+  /**
+   * DeleteChat deletes a group chat for all participants.
+   * @example
+   * await bot.chats.deleteChat({ chat_id: 123456789 });
+   */
+  deleteChat(req) {
+    return __async(this, null, function* () {
+      return this.client.request("DELETE", `${Paths.Chats}/${req.chat_id}`);
+    });
+  }
+  /**
+   * SendAction allows sending bot actions to a group chat (e.g., "typing").
+   * @example
+   * await bot.chats.sendAction({ chat_id: 123456789, action: "typing" });
+   */
+  sendAction(req) {
+    return __async(this, null, function* () {
+      return this.client.request("POST", `${Paths.Chats}/${req.chat_id}/actions`, {
+        payload: req
+      });
+    });
+  }
+  /**
+   * GetPinnedMessage returns the pinned message in a chat.
+   * @example
+   * const response = await bot.chats.getPinnedMessage({ chat_id: 123456789 });
+   */
+  getPinnedMessage(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", `${Paths.Chats}/${req.chat_id}/pin`);
+    });
+  }
+  /**
+   * PinMessage pins a message in a group chat.
+   * @example
+   * await bot.chats.pinMessage({ chat_id: 123456789, message_id: "456" });
+   */
+  pinMessage(req) {
+    return __async(this, null, function* () {
+      return this.client.request("PUT", `${Paths.Chats}/${req.chat_id}/pin`, {
+        payload: req
+      });
+    });
+  }
+  /**
+   * UnpinMessage removes the pinned message in a group chat.
+   * @example
+   * await bot.chats.unpinMessage({ chat_id: 123456789 });
+   */
+  unpinMessage(req) {
+    return __async(this, null, function* () {
+      return this.client.request("DELETE", `${Paths.Chats}/${req.chat_id}/pin`);
+    });
+  }
+  /**
+   * GetChatMembership returns the bot's membership details in a group chat.
+   * @example
+   * const response = await bot.chats.getChatMembership({ chat_id: 123456789 });
+   */
+  getChatMembership(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", `${Paths.Chats}/${req.chat_id}/members/me`);
+    });
+  }
+  /**
+   * LeaveChat removes the bot from a group chat.
+   * @example
+   * await bot.chats.leaveChat({ chat_id: 123456789 });
+   */
+  leaveChat(req) {
+    return __async(this, null, function* () {
+      return this.client.request("DELETE", `${Paths.Chats}/${req.chat_id}/members/me`);
+    });
+  }
+  /**
+   * GetChatAdmins returns a list of all group chat administrators.
+   * @example
+   * const response = await bot.chats.getChatAdmins({ chat_id: 123456789 });
+   */
+  getChatAdmins(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", `${Paths.Chats}/${req.chat_id}/members/admins`);
+    });
+  }
+  /**
+   * SetChatAdmins assigns a group member as an administrator.
+   * @example
+   * await bot.chats.setChatAdmins({ chat_id: 123456789, user_id: 456 });
+   */
+  setChatAdmins(req) {
+    return __async(this, null, function* () {
+      return this.client.request("POST", `${Paths.Chats}/${req.chat_id}/members/admins`, {
+        payload: req
+      });
+    });
+  }
+  /**
+   * DeleteAdmin revokes the user's administrator rights in a group chat.
+   * @example
+   * await bot.chats.deleteAdmin({ chat_id: 123456789, user_id: 456 });
+   */
+  deleteAdmin(req) {
+    return __async(this, null, function* () {
+      return this.client.request("DELETE", `${Paths.Chats}/${req.chat_id}/members/admins/${req.user_id}`);
+    });
+  }
+  /**
+   * GetChatMembers returns a list of participants in a group chat.
+   * @example
+   * const response = await bot.chats.getChatMembers({ chat_id: 123456789, limit: 50 });
+   */
+  getChatMembers(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", `${Paths.Chats}/${req.chat_id}/members`, {
+        query: req
+      });
+    });
+  }
+  /**
+   * AddMembers adds participants to a group chat.
+   * @example
+   * await bot.chats.addMembers({ chat_id: 123456789, user_ids: [456, 789] });
+   */
+  addMembers(req) {
+    return __async(this, null, function* () {
+      return this.client.request("POST", `${Paths.Chats}/${req.chat_id}/members`, {
+        payload: req
+      });
+    });
+  }
+  /**
+   * DeleteMember removes a participant from a group chat.
+   * @example
+   * await bot.chats.deleteMember({ chat_id: 123456789, user_id: 456 });
+   */
+  deleteMember(req) {
+    return __async(this, null, function* () {
+      return this.client.request("DELETE", `${Paths.Chats}/${req.chat_id}/members`, {
+        query: req
+      });
+    });
+  }
+};
+
+// src/api/helpers.ts
+var import_os = require("os");
+var import_path2 = require("path");
+var import_promises2 = require("fs/promises");
+
+// src/api/uploads.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_crypto = require("crypto");
+var UploadsService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * UploadFile uploads a file to MAX servers for subsequent transmission.
+   * It handles both the initial request for an upload URL and the actual multipart upload.
+   * @param req - Upload parameters (type, file_path).
+   * @returns Promise<UploadedInfo> containing the file token.
+   * @example
+   * const response = await bot.uploads.uploadFile({ type: "image", file_path: "./corgi.png" });
+   * console.log("File token:", file.token);
+   */
+  uploadFile(req) {
+    return __async(this, null, function* () {
+      const initResp = yield this.getupload_url(req.type);
+      if (!initResp.url) {
+        if (initResp.token) {
+          return { token: initResp.token };
+        }
+        throw new Error("Upload failed: server did not return an upload URL or token.");
+      }
+      let multipartResp;
+      try {
+        multipartResp = yield this.uploadMultipart(initResp.url, req.file_path);
+        if (multipartResp) {
+          if (multipartResp.token) {
+            return { token: multipartResp.token };
+          }
+          const anyResp = multipartResp;
+          if (anyResp.photos) {
+            const photoKeys = Object.keys(anyResp.photos);
+            if (photoKeys.length > 0 && anyResp.photos[photoKeys[0]].token) {
+              return { token: anyResp.photos[photoKeys[0]].token };
+            }
+          }
+        }
+      } catch (err) {
+        if (initResp.token) {
+          return { token: initResp.token };
+        }
+        throw err;
+      }
+      if (initResp.token) {
+        return { token: initResp.token };
+      }
+      throw new Error(`Server did not return a token after upload. Response: ${JSON.stringify(multipartResp)}`);
+    });
+  }
+  getupload_url(uploadType) {
+    return __async(this, null, function* () {
+      return this.client.request("POST", Paths.Uploads, {
+        query: { type: uploadType }
+      });
+    });
+  }
+  uploadMultipart(upload_url, file_path) {
+    return __async(this, null, function* () {
+      const fileData = yield (0, import_promises.readFile)(file_path);
+      const filename = (0, import_path.basename)(file_path);
+      const boundary = "----MaxBotFormBoundary" + (0, import_crypto.randomBytes)(16).toString("hex");
+      const CRLF = "\r\n";
+      const header = Buffer.from(
+        `--${boundary}${CRLF}Content-Disposition: form-data; name="file"; filename="${filename}"${CRLF}Content-Type: application/octet-stream${CRLF}${CRLF}`
+      );
+      const footer = Buffer.from(`${CRLF}--${boundary}--${CRLF}`);
+      const payload = Buffer.concat([header, fileData, footer]);
+      return this.client.request("POST", upload_url, {
+        body: payload,
+        headers: {
+          "Content-Type": `multipart/form-data; boundary=${boundary}`,
+          "Content-Length": payload.length.toString()
+        }
+      });
+    });
+  }
+};
+
+// src/models/schema.ts
+function attachImage(token, url) {
+  const payload = {};
+  if (token) payload.token = token;
+  if (url) payload.url = url;
+  return {
+    type: "image" /* Image */,
+    payload
+  };
+}
+function attachVideo(token, url) {
+  const payload = {};
+  if (token) payload.token = token;
+  if (url) payload.url = url;
+  return {
+    type: "video" /* Video */,
+    payload
+  };
+}
+function attachAudio(token, url) {
+  const payload = {};
+  if (token) payload.token = token;
+  if (url) payload.url = url;
+  return {
+    type: "audio" /* Audio */,
+    payload
+  };
+}
+function attachFile(token, url, filename) {
+  const payload = { filename: filename || "" };
+  if (token) payload.token = token;
+  if (url) payload.url = url;
+  return {
+    type: "file" /* File */,
+    payload
+  };
+}
+
+// src/api/helpers.ts
+var MIME_TO_EXT = {
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/webp": ".webp",
+  "video/mp4": ".mp4",
+  "audio/mpeg": ".mp3",
+  "audio/ogg": ".ogg",
+  "audio/wav": ".wav",
+  "application/pdf": ".pdf"
+};
+var HelpersService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * SendFile simplifies file sending by automatically determining if the source is a URL or a local path.
+   * @param req - File send request parameters.
+   * @example
+   * await bot.helpers.sendFile({ chat_id: 123, file_source: "./photo.jpg" });
+   * await bot.helpers.sendFile({ chat_id: 123, file_source: "https://site.com/image.png" });
+   */
+  sendFile(req) {
+    return __async(this, null, function* () {
+      if (this.isURL(req.file_source)) {
+        return this.sendFileByUrl(req);
+      }
+      return this.sendFileByUpload(req);
+    });
+  }
+  /**
+   * SendFileByUrl sends a file using a direct URL. If the file is not an image, 
+   * it will be downloaded to a temporary directory and uploaded to MAX servers.
+   * @param req - File send request with a URL in file_source.
+   */
+  sendFileByUrl(req) {
+    return __async(this, null, function* () {
+      const extInUrl = this.getExtension(req.file_source);
+      if (this.determineUploadType(extInUrl) === "image" /* Image */) {
+        const attachment2 = {
+          type: "image" /* Image */,
+          payload: { url: req.file_source }
+        };
+        return this.sendInternal(req, attachment2);
+      }
+      const { tempPath, ext } = yield this.downloadTempFile(req.file_source);
+      const uploadType = this.determineUploadType(ext);
+      const uploader = new UploadsService(this.client);
+      const uploadResp = yield uploader.uploadFile({
+        type: uploadType,
+        file_path: tempPath
+      });
+      const filename = (0, import_path2.basename)(req.file_source);
+      const attachment = this.buildAttachmentFromToken(uploadType, uploadResp.token, filename);
+      return this.sendInternal(req, attachment);
+    });
+  }
+  /**
+   * SendFileByUpload uploads a local file to MAX servers and sends it to the chat.
+   * @param req - File send request with a local path in file_source.
+   */
+  sendFileByUpload(req) {
+    return __async(this, null, function* () {
+      const ext = this.getExtension(req.file_source);
+      const uploadType = this.determineUploadType(ext);
+      const uploader = new UploadsService(this.client);
+      const uploadResp = yield uploader.uploadFile({
+        type: uploadType,
+        file_path: req.file_source
+      });
+      if (!uploadResp.token) {
+        throw new Error("Failed to auto-upload file: no token returned");
+      }
+      const filename = (0, import_path2.basename)(req.file_source);
+      const attachment = this.buildAttachmentFromToken(uploadType, uploadResp.token, filename);
+      return this.sendInternal(req, attachment);
+    });
+  }
+  sendInternal(req, attachment) {
+    return __async(this, null, function* () {
+      const allAttachments = [...req.attachments || [], attachment];
+      const requestPayload = {
+        user_id: req.user_id,
+        chat_id: req.chat_id,
+        text: req.text,
+        format: req.format,
+        attachments: allAttachments,
+        notify: req.notify,
+        link: req.link,
+        disable_link_preview: req.disable_link_preview
+      };
+      let lastErr;
+      for (let i = 0; i < 3; i++) {
+        try {
+          const response = yield this.client.request("POST", Paths.Messages, {
+            query: requestPayload,
+            payload: requestPayload
+          });
+          return response;
+        } catch (err) {
+          lastErr = err;
+          if (err.message && err.message.includes("not.ready")) {
+            yield new Promise((resolve) => setTimeout(resolve, 3e3));
+            continue;
+          }
+          break;
+        }
+      }
+      throw lastErr;
+    });
+  }
+  isURL(str) {
+    try {
+      const u = new URL(str);
+      return u.protocol === "http:" || u.protocol === "https:";
+    } catch (e) {
+      return false;
+    }
+  }
+  getExtension(source) {
+    if (this.isURL(source)) {
+      try {
+        const u = new URL(source);
+        return (0, import_path2.extname)(u.pathname).toLowerCase();
+      } catch (e) {
+        return "";
+      }
+    }
+    return (0, import_path2.extname)(source).toLowerCase();
+  }
+  determineUploadType(ext) {
+    switch (ext) {
+      case ".jpg":
+      case ".jpeg":
+      case ".png":
+      case ".webp":
+        return "image" /* Image */;
+      case ".mp4":
+      case ".avi":
+      case ".mov":
+        return "video" /* Video */;
+      case ".mp3":
+      case ".ogg":
+      case ".wav":
+        return "audio" /* Audio */;
+      default:
+        return "file" /* File */;
+    }
+  }
+  buildAttachmentFromToken(uType, token, filename) {
+    switch (uType) {
+      case "image" /* Image */:
+        return attachImage(token, "");
+      case "video" /* Video */:
+        return attachVideo(token, "");
+      case "audio" /* Audio */:
+        return attachAudio(token, "");
+      default:
+        return attachFile(token, "", filename);
+    }
+  }
+  downloadTempFile(urlStr) {
+    return __async(this, null, function* () {
+      const resp = yield fetch(urlStr);
+      if (!resp.ok) {
+        throw new Error(`Failed to download file: ${resp.statusText}`);
+      }
+      let contentType = resp.headers.get("Content-Type") || "";
+      contentType = contentType.split(";")[0].trim();
+      let ext = MIME_TO_EXT[contentType];
+      if (!ext) {
+        ext = this.getExtension(urlStr);
+      }
+      if (!ext) {
+        ext = ".bin";
+      }
+      const buffer = yield resp.arrayBuffer();
+      const tempFileName = `maxbot_${Date.now()}_${Math.floor(Math.random() * 1e4)}${ext}`;
+      const tempPath = (0, import_path2.join)((0, import_os.tmpdir)(), tempFileName);
+      yield (0, import_promises2.writeFile)(tempPath, Buffer.from(buffer));
+      return { tempPath, ext };
+    });
+  }
+};
+
+// src/api/messages.ts
+var MessagesService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * GetMessages returns information about a message or an array of messages from a chat.
+   * @param req - Query parameters (chat_id, user_id, limit, etc.).
+   * @example
+   * const response = await bot.messages.getMessages({ chat_id: 123, limit: 10 });
+   */
+  getMessages(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", Paths.Messages, {
+        query: req
+      });
+    });
+  }
+  /**
+   * SendMessage sends a text or media message to a specified user or chat.
+   * @param req - Message parameters including text and attachments.
+   * @example
+   * await bot.messages.sendMessage({ user_id: 123, text: "Hello!" });
+   */
+  sendMessage(req) {
+    return __async(this, null, function* () {
+      return this.client.request("POST", Paths.Messages, {
+        query: req,
+        payload: req
+      });
+    });
+  }
+  /**
+   * EditMessage edits the text or media of a previously sent message.
+   * @param req - Edit parameters (message_id, new text, etc.).
+   * @example
+   * await bot.messages.editMessage({ message_id: 456, text: "Updated text" });
+   */
+  editMessage(req) {
+    return __async(this, null, function* () {
+      return this.client.request("PUT", Paths.Messages, {
+        query: req,
+        payload: req
+      });
+    });
+  }
+  /**
+   * DeleteMessage deletes a message from a chat.
+   * @example
+   * await bot.messages.deleteMessage({ chat_id: 123, message_id: 456 });
+   */
+  deleteMessage(req) {
+    return __async(this, null, function* () {
+      return this.client.request("DELETE", Paths.Messages, {
+        query: req
+      });
+    });
+  }
+  /**
+   * GetMessage extracts the content and metadata of a specific message by its ID.
+   * @example
+   * const response = await bot.messages.getMessage({ message_id: 456 });
+   */
+  getMessage(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", `${Paths.Messages}/${req.message_id}`);
+    });
+  }
+  /**
+   * GetVideoInfo returns detailed information about an attached video.
+   * @example
+   * const response = await bot.messages.getVideoInfo({ video_token: "video123" });
+   */
+  getVideoInfo(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", `${Paths.Videos}/${req.video_token}`);
+    });
+  }
+  /**
+   * AnswerCallback sends a response after a user clicks a button.
+   * @example
+   * await bot.messages.answerCallback({ callback_id: "cb123", text: "Got it!" });
+   */
+  answerCallback(req) {
+    return __async(this, null, function* () {
+      return this.client.request("POST", Paths.Answers, {
+        query: req,
+        payload: req
+      });
+    });
+  }
+};
+
+// src/api/subscriptions.ts
+var SubscriptionsService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * GetSubscriptions returns a list of webhook notification subscriptions.
+   * @example
+   * const response = await bot.subscriptions.getSubscriptions();
+   */
+  getSubscriptions() {
+    return __async(this, null, function* () {
+      return this.client.request("GET", Paths.Subscriptions);
+    });
+  }
+  /**
+   * Subscribe configures the delivery of bot events via a webhook.
+   * @param req - Subscription parameters (url, types).
+   * @example
+   * await bot.subscriptions.subscribe({ url: "https://my.site/webhook", types: ["message.created"] });
+   */
+  subscribe(req) {
+    return __async(this, null, function* () {
+      return this.client.request("POST", Paths.Subscriptions, {
+        payload: req
+      });
+    });
+  }
+  /**
+   * Unsubscribe cancels the bot's subscription to receiving updates via webhook.
+   * @example
+   * await bot.subscriptions.unsubscribe({ url: "https://my.site/webhook" });
+   */
+  unsubscribe(req) {
+    return __async(this, null, function* () {
+      return this.client.request("DELETE", Paths.Subscriptions, {
+        query: req
+      });
+    });
+  }
+  /**
+   * GetUpdates retrieves incoming updates (Long-polling).
+   * @param req - Polling parameters (marker, timeout, limit).
+   * @example
+   * const response = await bot.subscriptions.getUpdates({ timeout: 25 });
+   */
+  getUpdates(req) {
+    return __async(this, null, function* () {
+      return this.client.request("GET", Paths.Updates, {
+        query: req
+      });
+    });
+  }
+};
+
+// src/api/api.ts
+var MaxBotAPI = class {
+  constructor(cfg) {
+    this.client = new APIClient(cfg);
+    this.bots = new BotsService(this.client);
+    this.chats = new ChatsService(this.client);
+    this.helpers = new HelpersService(this.client);
+    this.messages = new MessagesService(this.client);
+    this.subscriptions = new SubscriptionsService(this.client);
+    this.uploads = new UploadsService(this.client);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MaxBotAPI
+});