@effect-ak/tg-bot-client 0.1.0 → 0.2.0

package/dist/esm/bot/update-poller/fetch-updates.js

@@ -0,0 +1,49 @@
+import * as Micro from "effect/Micro";
+import { extractUpdate } from "../../bot/message-handler/utils.js";
+export const fetchUpdates = ({ state, settings, execute, handlers }) => Micro.gen(function* () {
+    const updateId = state.lastUpdateId;
+    console.info("getting updates", state);
+    const updates = yield* execute("get_updates", {
+        ...settings,
+        ...(updateId ? { offset: updateId } : undefined)
+    }).pipe(Micro.andThen(_ => _.sort(_ => _.update_id)));
+    let lastSuccessId = undefined;
+    let hasError = false;
+    for (const updateObject of updates) {
+        const update = extractUpdate(updateObject);
+        if (!update) {
+            console.warn("Unknown update", update);
+            hasError = true;
+            break;
+        }
+        const handler = handlers[`on_${update.type}`];
+        if (!handler) {
+            console.warn("Handler for update not defined", update);
+            hasError = true;
+            break;
+        }
+        const handleResult = handler(update);
+        if ("chat" in update) {
+            const response = yield* execute(`send_${handleResult.type}`, {
+                ...handleResult,
+                chat_id: update.chat.id
+            });
+            console.log("bot response", response);
+        }
+        if (!handleResult) {
+            hasError = true;
+            console.log(handleResult);
+            break;
+        }
+        ;
+        lastSuccessId = updateObject.update_id;
+    }
+    if (hasError && lastSuccessId) {
+        const resp = //commit successfully handled messages
+         yield* execute("get_updates", {
+            offset: lastSuccessId,
+            limit: 0
+        });
+    }
+    return { updates, lastSuccessId, hasError };
+});

package/dist/esm/bot/update-poller/poll-and-handle.js

@@ -0,0 +1,37 @@
+import * as Micro from "effect/Micro";
+import { makeSettingsFrom } from "./settings.js";
+import { fetchUpdates } from "./fetch-updates.js";
+export const pollAndHandle = (input) => {
+    const state = {
+        lastUpdateId: undefined,
+        emptyResponses: 0
+    };
+    const settings = makeSettingsFrom(input.settings);
+    return Micro.delay(1000)(fetchUpdates({
+        state, settings,
+        execute: input.execute,
+        handlers: input.settings,
+    })).pipe(Micro.repeat({
+        while: ({ updates, lastSuccessId, hasError }) => {
+            if (hasError) {
+                console.warn("error in handler, quitting");
+                return false;
+            }
+            if (updates.length == 0) {
+                state.emptyResponses += 1;
+                if (state.emptyResponses > 200) {
+                    console.info("too many empty responses, quitting");
+                    return false;
+                }
+            }
+            else {
+                state.emptyResponses = 0;
+            }
+            ;
+            if (lastSuccessId) {
+                state.lastUpdateId = lastSuccessId + 1;
+            }
+            return true;
+        }
+    }));
+};

package/dist/esm/bot/update-poller/settings.js

@@ -0,0 +1,15 @@
+export const makeSettingsFrom = (input) => {
+    let limit = input.batch_size ?? 10;
+    let timeout = input.timeout ?? 10;
+    if (limit < 10 || limit > 100) {
+        console.warn("Wrong limit, must be in [10..100], using 10 instead");
+        limit = 10;
+    }
+    if (timeout < 2 || timeout > 10) {
+        console.warn("Wrong timeout, must be in [2..10], using 2 instead");
+        limit = 10;
+    }
+    return {
+        limit, timeout
+    };
+};

package/dist/esm/client/_client.js

@@ -1,15 +1,16 @@
-import { makeExecute } from "./execute-request.js";
-import { makeDownloadFile } from "./download-file.js";
-import { defaultBaseUrl } from "./const.js";
-export const makeTgBotClient = (inputConfig) => {
-    const config = {
-        ...inputConfig,
-        baseUrl: inputConfig.baseUrl ?? defaultBaseUrl
-    };
-    const execute = makeExecute(config);
-    const file = makeDownloadFile(config, execute);
-    return {
-        ...execute,
-        ...file
-    };
+import * as Micro from "effect/Micro";
+import { makeTgBotClientConfig, TgBotClientConfig } from "./config.js";
+import { ClientExecuteRequestService, ClientExecuteRequestServiceDefault } from "./execute-request/_service.js";
+import { ClientFileService, ClientFileServiceDefault } from "./file/_service.js";
+export const makeTgBotClient = (input) => {
+    const config = makeTgBotClientConfig(input);
+    const client = Micro.gen(function* () {
+        const execute = yield* Micro.service(ClientExecuteRequestService);
+        const file = yield* Micro.service(ClientFileService);
+        return {
+            execute: (method, input) => execute.execute(method, input).pipe(Micro.runPromise),
+            getFile: (input) => file.getFile(input).pipe(Micro.runPromise)
+        };
+    }).pipe(Micro.provideServiceEffect(ClientExecuteRequestService, ClientExecuteRequestServiceDefault), Micro.provideServiceEffect(ClientFileService, ClientFileServiceDefault), Micro.provideService(TgBotClientConfig, config), Micro.runSync);
+    return client;
 };

package/dist/esm/client/config.js

@@ -0,0 +1,8 @@
+import * as Context from "effect/Context";
+import { defaultBaseUrl } from "../const.js";
+export const makeTgBotClientConfig = (input) => TgBotClientConfig.of({
+    ...input,
+    ["base-url"]: input["base-url"] ?? defaultBaseUrl
+});
+export class TgBotClientConfig extends Context.Tag("TgBotClientConfig")() {
+}

package/dist/esm/client/errors.js

@@ -1,12 +1,9 @@
-export class TgBotClientError extends Error {
-    reason;
-    _tag = "TgBotClientError";
-    constructor(reason) {
-        super();
-        this.reason = reason;
-    }
+import * as Data from "effect/Data";
+export class TgBotClientError extends Data.TaggedError("TgBotClientError") {
     static missingSuccess = new TgBotClientError({
-        type: "ClientInternalError",
-        cause: "Expected 'success' to be defined"
+        reason: {
+            type: "ClientInternalError",
+            cause: "Expected 'success' to be defined"
+        },
     });
 }

package/dist/esm/client/execute-request/_service.js

@@ -0,0 +1,12 @@
+import * as Micro from "effect/Micro";
+import * as Context from "effect/Context";
+import { TgBotClientConfig } from "../config.js";
+import { execute } from "./execute.js";
+export class ClientExecuteRequestService extends Context.Tag("ClientExecuteRequestService")() {
+}
+export const ClientExecuteRequestServiceDefault = Micro.gen(function* () {
+    const config = yield* Micro.service(TgBotClientConfig);
+    return {
+        execute: (method, input) => execute(config, method, input)
+    };
+});

package/dist/esm/client/execute-request/execute.js

@@ -0,0 +1,37 @@
+import * as Micro from "effect/Micro";
+import * as String from "effect/String";
+import { TgBotClientError } from "../errors.js";
+import { makePayload } from "./payload.js";
+import { isTgBotApiResponse } from "../guards.js";
+export const execute = (config, method, input) => Micro.gen(function* () {
+    const httpResponse = yield* Micro.tryPromise({
+        try: () => fetch(`${config["base-url"]}/bot${config["bot-token"]}/${String.snakeToCamel(method)}`, {
+            body: makePayload(input) ?? null,
+            method: "POST",
+        }),
+        catch: cause => new TgBotClientError({
+            reason: { type: "ClientInternalError", cause }
+        })
+    });
+    const response = yield* Micro.tryPromise({
+        try: () => httpResponse.json(),
+        catch: () => new TgBotClientError({
+            reason: { type: "UnexpectedResponse", response: httpResponse }
+        })
+    });
+    if (!isTgBotApiResponse(response)) {
+        return yield* Micro.fail(new TgBotClientError({
+            reason: { type: "UnexpectedResponse", response }
+        }));
+    }
+    if (!httpResponse.ok) {
+        return yield* Micro.fail(new TgBotClientError({
+            reason: {
+                type: "NotOkResponse",
+                ...(response.error_code ? { errorCode: response.error_code } : undefined),
+                ...(response.description ? { details: response.description } : undefined)
+            }
+        }));
+    }
+    return response.result;
+});

package/dist/esm/client/{request.js → execute-request/payload.js}

@@ -1,6 +1,4 @@
-const hasFileContent = (input) => (typeof input == "object" && input != null) &&
-    ("file_content" in input && input.file_content instanceof Uint8Array) &&
-    ("file_name" in input && typeof input.file_name === "string" && input.file_name.length > 0);
+import { isFileContent } from "../guards.js";
 export const makePayload = (body) => {
     const entries = Object.entries(body);
     if (entries.length == 0)
@@ -12,7 +10,7 @@ export const makePayload = (body) => {
         if (typeof value != "object") {
             result.append(key, `${value}`);
         }
-        else if (hasFileContent(value)) {
+        else if (isFileContent(value)) {
             result.append(key, new Blob([value.file_content]), value.file_name);
         }
         else {

package/dist/esm/client/file/_service.js

@@ -0,0 +1,14 @@
+import * as Micro from "effect/Micro";
+import * as Context from "effect/Context";
+import { TgBotClientConfig } from "../config.js";
+import { ClientExecuteRequestService, ClientExecuteRequestServiceDefault } from "../execute-request/_service.js";
+import { getFile } from "./get-file.js";
+export class ClientFileService extends Context.Tag("ClientFileService")() {
+}
+export const ClientFileServiceDefault = Micro.gen(function* () {
+    const config = yield* Micro.service(TgBotClientConfig);
+    const execute = yield* Micro.service(ClientExecuteRequestService);
+    return {
+        getFile: (input) => getFile(input.file_id, config, execute)
+    };
+}).pipe(Micro.provideServiceEffect(ClientExecuteRequestService, ClientExecuteRequestServiceDefault));

package/dist/esm/client/file/get-file.js

@@ -0,0 +1,24 @@
+import * as Micro from "effect/Micro";
+import { TgBotClientError } from "../errors.js";
+export const getFile = (fileId, config, execute) => Micro.gen(function* () {
+    const response = yield* execute.execute("get_file", { file_id: fileId });
+    const file_path = response.file_path;
+    if (!file_path || file_path.length == 0) {
+        return yield* Micro.fail(new TgBotClientError({
+            reason: {
+                type: "UnableToGetFile",
+                cause: "File path not defined"
+            }
+        }));
+    }
+    const file_name = file_path.replaceAll("/", "-");
+    const url = `${config["base-url"]}/file/bot${config["bot-token"]}/${file_path}`;
+    const fileContent = yield* Micro.tryPromise({
+        try: () => fetch(url).then(_ => _.arrayBuffer()),
+        catch: cause => new TgBotClientError({
+            reason: { type: "UnableToGetFile", cause }
+        })
+    });
+    const file = new File([new Uint8Array(fileContent)], file_name);
+    return file;
+});

package/dist/esm/client/guards.js

@@ -0,0 +1,7 @@
+export const isFileContent = (input) => (typeof input == "object" && input != null) &&
+    ("file_content" in input && input.file_content instanceof Uint8Array) &&
+    ("file_name" in input && typeof input.file_name == "string");
+export const isTgBotApiResponse = (input) => (typeof input == "object" && input != null) &&
+    ("ok" in input && typeof input.ok == "boolean");
+export const isTgBotClientSettingsInput = (input) => (typeof input == "object" && input != null) &&
+    ("bot-token" in input && typeof input["bot-token"] == "string");

package/dist/esm/index.js

@@ -1,4 +1,5 @@
-export * from "./client/const.js";
 export * from "./client/_client.js";
-// export * from "./specification/api.js"
-// export * from "./specification/types.js"
+export * from "./bot/run.js";
+export * from "./specification/api.js";
+export * from "./specification/types.js";
+export * from "./const.js";

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@effect-ak/tg-bot-client",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
+  "homepage": "https://effect-ak.github.io/telegram-bot-client",
   "author": {
     "name": "Aleksandr Kondaurov",
     "email": "kondaurov.dev@gmail.com"
@@ -30,22 +31,26 @@
     "@babel/plugin-transform-export-namespace-from": "^7.25.9",
     "@babel/plugin-transform-modules-commonjs": "^7.26.3",
     "@types/node": "^22.10.1",
-    "effect": "^3.11.4",
+    "@types/js-yaml": "^4.0.9",
+    "js-yaml": "^4.1.0",
     "node-html-parser": "^6.1.13",
     "openapi-types": "^12.1.3",
     "ts-morph": "^24.0.0",
     "tsc-alias": "^1.8.10",
-    "type-fest": "^4.30.0",
+    "tsx": "^4.19.2",
     "typescript": "^5.7.2",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^2.1.8",
-    "@redocly/cli": "^1.26.0"
+    "vitest": "^2.1.8"
+  },
+  "dependencies": {
+    "effect": "^3.4.0"
   },
   "scripts": {
-    "gen": "bun run ./codegen/main",
+    "docgen": "docgen",
+    "gen": "tsx ./codegen/main",
+    "run-bot": "tsx ./src/bot/run",
     "build": "pnpm build-esm && pnpm build-cjs",
     "build-esm": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    "build-cjs": "babel dist/esm --out-dir dist/cjs",
-    "gen-html": "redocly build-docs --output ../effect-ak.github.io/telegram-bot-api/index.html"
+    "build-cjs": "babel dist/esm --out-dir dist/cjs"
   }
 }

package/readme.md

@@ -1,34 +1,29 @@
-![NPM Version](https://img.shields.io/npm/v/%40effect-ak%2Ftg-bot-client)
+[![NPM Version](https://img.shields.io/npm/v/%40effect-ak%2Ftg-bot-client)](https://www.npmjs.com/package/@effect-ak/tg-bot-client)
+[![OpenAPI](https://img.shields.io/badge/OpenAPI-3.1-blue.svg)](https://effect-ak.github.io/telegram-bot-api/)
+![NPM Unpacked Size](https://img.shields.io/npm/unpacked-size/%40effect-ak%2Ftg-bot-client)
+![NPM Downloads](https://img.shields.io/npm/dw/%40effect-ak%2Ftg-bot-client)
 
-[OpenApi Specification](https://effect-ak.github.io/telegram-bot-api/)
 
-### What is it? 
 
-This is a client for interacting with the Telegram Bot API.  
-The main reason for creating this package is that Telegram does not provide an SDK for working with their API.
+### Motivation
 
-They only provide documentation in the form of a massive HTML page, which is very inconvenient for navigating and understanding what the Telegram Bot API offers.
+The official documentation is available as a comprehensive [HTML page](https://core.telegram.org/bots/api), providing basic navigation. While functional, relying solely on this format can be somewhat inconvenient during bot development.
 
-## Features:
-- **Pure TypeScript Client**: This is a clean client written in TypeScript with no abstractions.
-- **Complete**: The entire API is generated from the official documentation [https://core.telegram.org/bots/api](https://core.telegram.org/bots/api) using a [code generator](./codegen/main.ts).
-- ~~**Inline Documentation**: No need to read lengthy official documentation. All types and comments are available in JS DOC, allowing you to develop your bot without leaving your IDE.~~
-  - Codegenerator produces TypeScript code and OpenApi specification now! Documentation was removed from TypeScript interfaces in order to keep npm package smaller.
+This client facilitates interaction with the Telegram Bot API. It was created primarily because Telegram does not offer an official SDK for their API.
 
+## Features:
+- **Typesafe Client**: This is a clean client written in TypeScript with no abstractions.
+- **Complete**: The entire API is generated from [the official documentation](https://core.telegram.org/bots/api) using a [code generator](./codegen/main.ts)
+- **Readable Method Names**: Method names, such as `setChatAdministratorCustomTitle`, are converted to snake_case for easier code readability, e.g., `set_chat_administrator_custom_title`.
 - **Type Mapping**: Types from the documentation are converted to TypeScript types:
   - `Integer` becomes `number`
   - `True` becomes `boolean`
   - `String or Number` becomes `string | number`
   - Enumerated types, such as `Type of the chat, can be either “private”, “group”, “supergroup” or “channel”` becomes a standard union of literal types `"private"| "group" | "supergroup" | "channel"`
   - And so on
-- **Readable Method Names**: Method names, such as `SetChatAdministratorCustomTitleInput`, are converted to snake_case for easier code readability, e.g., `set_chat_administrator_custom_title`.
 
 ### Usage example
 
-#### Install
-
-`npm i @effect-ak/tg-bot-client`
-
 #### Creating a Client
 
 ```typescript
@@ -39,17 +34,13 @@ const client = makeTgBotClient({
 });
 ```
 
-#### Executing api methods, typesafety
+#### Executing api methods
 
 `client` has an `execute` method which requires two arguments
 
 - the first is the API method, e.g. `send_message`
 - the second is an object containing the arguments for that method, e.g. `text`
 
-`execute` never returns failed promise, instead, it gives an object with two fields, `success`, `error`.
-
-if you want, you can use unsafe alternative, `unsafeExecute`, which gives you the result of method or throws an Error
-
 #### 1. Sending a Message with an Effect
 
 ```typescript
@@ -99,11 +90,70 @@ const file =
   await client.getFile({ 
     file_id: fileId
   });
-// file is File
 ```
 
----
+### Chatbot Support
+
+You can write the logic for your chatbot and run it locally.
+
+Take a look at [example](./example/echo-bot.ts)
+
+The Telegram bot supports both push and pull notification models for messages. This package uses the **pull** model for several reasons:
+
+- **Flexibility in Handler Deployment:** Allows you to run the bot handler on any JS platform (NodeJs, Browser) 
+- **Sequential Message Processing:** Messages in the queue are read one by one, and the handler is invoked for each message. If an error occurs in the handler, the next message remains in the queue, and the bot stops running. When the handler successfully processes a message, it proceeds to the next one.
+
+### Setup Instructions
+
+1. **Create a `config.json` File**
+
+   In the root of your project, create a `config.json` file with the following content:
+
+   ```json
+   {
+     "bot-token": "your-token"
+   }
+   ```
+
+   Replace `"your-token"` with your actual Telegram bot token.
+
+2. **Create `bot.js` and Implement Your Bot's Logic**
+
+   Create a file named `bot.js` and add your bot's logic as shown below:
+
+   ```typescript
+   import { MESSAGE_EFFECTS, runTgChatBot } from "@effect-ak/tg-bot-client"
+
+   runTgChatBot({
+     type: "fromJsonFile",
+     on_message: (msg) => {
+       if (msg?.text === "bye") {
+         return {
+           type: "message",
+           text: "See you later!",
+           message_effect_id: MESSAGE_EFFECTS["❤️"]
+         }
+       }
+
+       return {
+         type: "message",
+         text: "I'm a simple bot"
+       }
+     }
+   })
+   ```
+
+   **Explanation:**
+   - **Import Statements:** Import necessary modules from the `@effect-ak/tg-bot-client` package.
+   - **`runTgChatBot` Function:** Initializes the Telegram chatbot using the configuration from the `config.json` file.
+   - **`on_message` Handler:** Defines the logic for handling incoming messages.
+     - If the message text is `"bye"`, the bot responds with `"See you later!"` and adds a heart emoji effect.
+     - For any other message, the bot responds with `"I'm a simple bot"`.
+
+3. **Run the Bot**
 
-### Summary
+   To start your chatbot, execute the following command in your terminal:
 
-This code generator and client will continue to be developed. However, for now, I have generated all the methods and types. If you find any errors, please let me know.
+   ```bash
+   node bot.js
+   ```

package/dist/cjs/client/download-file.js

@@ -1,44 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeDownloadFile = void 0;
-var _errors = require("./errors.js");
-const makeDownloadFile = (config, execute) => {
-  const getFile = async input => {
-    const response = await execute.execute("get_file", input);
-    if (response.error) return {
-      error: response.error
-    };
-    const file_path = response.success?.file_path;
-    if (!file_path || file_path.length == 0) {
-      return {
-        error: new _errors.TgBotClientError({
-          type: "UnableToGetFile",
-          cause: "File path not defined"
-        })
-      };
-    }
-    const file_name = file_path.replaceAll("/", "-");
-    const url = `${config.baseUrl}/file/bot${config.token}/${file_path}`;
-    try {
-      const fileContent = await fetch(url).then(_ => _.arrayBuffer());
-      const file = new File([new Uint8Array(fileContent)], file_name);
-      return {
-        success: file
-      };
-    } catch (cause) {
-      return {
-        error: new _errors.TgBotClientError({
-          type: "UnableToGetFile",
-          cause
-        })
-      };
-    }
-  };
-  return {
-    getFile
-  };
-};
-exports.makeDownloadFile = makeDownloadFile;

package/dist/cjs/client/execute-request.js

@@ -1,69 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeExecute = void 0;
-var _request = require("./request.js");
-var _response = require("./response.js");
-var _errors = require("./errors.js");
-const makeExecute = config => {
-  const execute = async (method, input) => {
-    try {
-      const httpResponse = await fetch(`${config.baseUrl}/bot${config.token}/${snakeToCamel(method)}`, {
-        body: (0, _request.makePayload)(input) ?? null,
-        method: "POST"
-      });
-      const response = await httpResponse.json();
-      if (!(0, _response.isTgBotApiResponse)(response)) {
-        return {
-          error: new _errors.TgBotClientError({
-            type: "UnexpectedResponse",
-            response
-          })
-        };
-      }
-      if (!httpResponse.ok) {
-        return {
-          error: new _errors.TgBotClientError({
-            type: "NotOkResponse",
-            ...(response.error_code ? {
-              errorCode: response.error_code
-            } : undefined),
-            ...(response.description ? {
-              details: response.description
-            } : undefined)
-          })
-        };
-      }
-      return {
-        success: response.result
-      };
-    } catch (cause) {
-      return {
-        error: new _errors.TgBotClientError({
-          type: "ClientInternalError",
-          cause
-        })
-      };
-    }
-  };
-  const unsafeExecute = async (method, input) => {
-    const result = await execute(method, input);
-    if (result.error) throw result.error;
-    if (!("success" in result)) throw _errors.TgBotClientError.missingSuccess;
-    return result.success;
-  };
-  return {
-    execute,
-    unsafeExecute
-  };
-};
-exports.makeExecute = makeExecute;
-const snakeToCamel = methodName => methodName.split("_").reduce((result, word, step) => {
-  if (step == 0) {
-    return word;
-  } else {
-    return result + word.at(0)?.toUpperCase() + word.slice(1);
-  }
-}, "");

package/dist/cjs/client/response.js

@@ -1,22 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isTgBotApiResponse = void 0;
-const isTgBotApiResponse = input => {
-  if (typeof input !== "object" || input == null) {
-    return false;
-  }
-  if (!("ok" in input && typeof input.ok == "boolean")) {
-    return false;
-  }
-  if ("error_code" in input && typeof input.error_code != "number") {
-    return false;
-  }
-  if ("description" in input && typeof input.description != "string") {
-    return false;
-  }
-  return true;
-};
-exports.isTgBotApiResponse = isTgBotApiResponse;

package/dist/dts/client/download-file.d.ts

@@ -1,13 +0,0 @@
-import type { BotConfig } from "./_client.js";
-import { TgBotClientError } from "./errors.js";
-import type { ExecuteRequest } from "./execute-request.js";
-type GetFileResult = {
-    success?: File;
-    error?: TgBotClientError;
-};
-export declare const makeDownloadFile: (config: BotConfig, execute: ExecuteRequest) => {
-    readonly getFile: (input: {
-        file_id: string;
-    }) => Promise<GetFileResult>;
-};
-export {};

package/dist/dts/client/execute-request.d.ts

@@ -1,13 +0,0 @@
-import type { BotConfig } from "./_client.js";
-import type { Api } from "../specification/api.js";
-import { TgBotClientError } from "./errors.js";
-export type ExecuteRequest = ReturnType<typeof makeExecute>;
-type SafeExecuteResult<M extends keyof Api> = {
-    success?: ReturnType<Api[M]>;
-    error?: TgBotClientError;
-};
-export declare const makeExecute: (config: BotConfig) => {
-    readonly execute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<SafeExecuteResult<M>>;
-    readonly unsafeExecute: <M extends keyof Api>(method: M, input: Parameters<Api[M]>[0]) => Promise<ReturnType<Api[M]>>;
-};
-export {};

package/dist/dts/client/response.d.ts

@@ -1,7 +0,0 @@
-export type TgBotApiResponse<O> = {
-    ok: boolean;
-    error_code?: number;
-    description?: string;
-    result?: O;
-};
-export declare const isTgBotApiResponse: <O>(input: unknown) => input is TgBotApiResponse<O>;