gramio 0.0.50 → 0.1.0

package/dist/composer.d.ts

@@ -1,34 +0,0 @@
-import type { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
-import { type CaughtMiddlewareHandler, type Middleware, Composer as MiddlewareComposer } from "middleware-io";
-import type { AnyBot, Handler, Hooks } from "./types";
-/** Base-composer without chainable type-safety */
-export declare class Composer {
-    protected composer: MiddlewareComposer<Context<AnyBot> & {
-        [key: string]: unknown;
-    }, Context<AnyBot> & {
-        [key: string]: unknown;
-    }>;
-    length: number;
-    composed: Middleware<Context<AnyBot>>;
-    protected onError: CaughtMiddlewareHandler<Context<AnyBot>>;
-    constructor(onError?: CaughtMiddlewareHandler<Context<any>>);
-    /** Register handler to one or many Updates */
-    on<T extends UpdateName>(updateName: MaybeArray<T>, handler: Handler<any>): this;
-    /** Register handler to any Update */
-    use(handler: Handler<any>): this;
-    /**
-     * Derive some data to handlers
-     *
-     * @example
-     * ```ts
-     * new Bot("token").derive((context) => {
-     * 		return {
-     * 			superSend: () => context.send("Derived method")
-     * 		}
-     * })
-     * ```
-     */
-    derive<Update extends UpdateName, Handler extends Hooks.Derive<ContextType<AnyBot, Update>>>(updateNameOrHandler: MaybeArray<Update> | Handler, handler?: Handler): this;
-    protected recompose(): this;
-    compose(context: Context<AnyBot>, next?: import("middleware-io").NextMiddleware): void;
-}

package/dist/composer.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Composer = void 0;
-const middleware_io_1 = require("middleware-io");
-/** Base-composer without chainable type-safety */
-class Composer {
-    composer = middleware_io_1.Composer.builder();
-    length = 0;
-    composed;
-    onError;
-    constructor(onError) {
-        this.onError =
-            onError ||
-                ((_, error) => {
-                    throw error;
-                });
-        this.recompose();
-    }
-    /** Register handler to one or many Updates */
-    on(updateName, handler) {
-        return this.use(async (context, next) => {
-            if (context.is(updateName))
-                return await handler(context, next);
-            return await next();
-        });
-    }
-    /** Register handler to any Update */
-    use(handler) {
-        this.composer.caught(this.onError).use(handler);
-        return this.recompose();
-    }
-    /**
-     * Derive some data to handlers
-     *
-     * @example
-     * ```ts
-     * new Bot("token").derive((context) => {
-     * 		return {
-     * 			superSend: () => context.send("Derived method")
-     * 		}
-     * })
-     * ```
-     */
-    derive(updateNameOrHandler, handler) {
-        if (typeof updateNameOrHandler === "function")
-            this.use(async (context, next) => {
-                for (const [key, value] of Object.entries(await updateNameOrHandler(context))) {
-                    context[key] = value;
-                }
-                next();
-            });
-        else if (handler)
-            this.on(updateNameOrHandler, async (context, next) => {
-                for (const [key, value] of Object.entries(await handler(context))) {
-                    context[key] = value;
-                }
-                next();
-            });
-        return this;
-    }
-    recompose() {
-        // @ts-expect-error middleware-io moment
-        this.composed = this.composer.compose();
-        this.length = this.composer.length;
-        return this;
-    }
-    compose(context, next = middleware_io_1.noopNext) {
-        this.composed(context, next);
-    }
-}
-exports.Composer = Composer;

package/dist/errors.d.ts

@@ -1,17 +0,0 @@
-import type { APIMethods, TelegramAPIResponseError, TelegramResponseParameters } from "@gramio/types";
-import type { MaybeSuppressedParams } from "./types";
-/** Symbol to determine which error kind is it */
-export declare const ErrorKind: symbol;
-/** Represent {@link TelegramAPIResponseError} and thrown in API calls */
-export declare class TelegramError<T extends keyof APIMethods> extends Error {
-    /** Name of the API Method */
-    method: T;
-    /** Params that were sent */
-    params: MaybeSuppressedParams<T>;
-    /** See  {@link TelegramAPIResponseError.error_code}*/
-    code: number;
-    /** Describes why a request was unsuccessful. */
-    payload?: TelegramResponseParameters;
-    /** Construct new TelegramError */
-    constructor(error: TelegramAPIResponseError, method: T, params: MaybeSuppressedParams<T>);
-}

package/dist/errors.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelegramError = exports.ErrorKind = void 0;
-/** Symbol to determine which error kind is it */
-exports.ErrorKind = Symbol("ErrorKind");
-/** Represent {@link TelegramAPIResponseError} and thrown in API calls */
-class TelegramError extends Error {
-    /** Name of the API Method */
-    method;
-    /** Params that were sent */
-    params;
-    /** See  {@link TelegramAPIResponseError.error_code}*/
-    code;
-    /** Describes why a request was unsuccessful. */
-    payload;
-    /** Construct new TelegramError */
-    constructor(error, method, params) {
-        super(error.description);
-        this.name = method;
-        this.method = method;
-        this.params = params;
-        this.code = error.error_code;
-        if (error.parameters)
-            this.payload = error.parameters;
-    }
-}
-exports.TelegramError = TelegramError;
-//@ts-expect-error
-TelegramError.constructor[exports.ErrorKind] = "TELEGRAM";

package/dist/filters.d.ts

@@ -1,20 +0,0 @@
-import type { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
-import type { Bot } from "./bot";
-export interface AdditionDefinitions {
-    equal: any;
-    addition: Record<string, any>;
-}
-type ReturnIfNonNever<T> = [T] extends [never] ? {} : T;
-export type Filters<BotType extends Bot = Bot, Base = Context<BotType>, ConditionalAdditions extends AdditionDefinitions[] = []> = {
-    _s: Base;
-    _ad: ConditionalAdditions;
-    __filters: ((context: Context<BotType>) => boolean)[];
-    context<T extends UpdateName>(updateName: MaybeArray<T>): Filters<BotType, ContextType<BotType, T>, ConditionalAdditions>;
-    is2(): Filters<BotType, 2, ConditionalAdditions>;
-} & ReturnIfNonNever<{
-    [K in keyof ConditionalAdditions & number]: ConditionalAdditions[K] extends {
-        equal: infer E;
-        addition: infer T;
-    } ? Base extends E ? T : {} : {};
-}[number]>;
-export {};

package/dist/filters.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// type filter = Filters<
-// 	Context<Bot> & {prop: 2},
-// 	[{ equal: { prop: 2 }; addition: { some: 2 } }]
-// >;
-// const a = {} as filter;
-// // a.s;
-// type S = [{ equal: { prop: 2 }; addition: { some: 2 } }];
-// type C = {[K in keyof S & number]: S[K]};
-// type SA = {
-// 	[K in keyof S & number]: S[K] extends {
-// 		equal: infer E;
-// 		addition: infer T;
-// 	} ? Context<Bot> & {prop: 2} extends E ? T : {} : {}}[number];
-// type A = Context<Bot> & {prop: 2} extends SA ? true : false;
-// export const filters: Filters = {
-// 	__filters: [],
-// 	context(updateName) {
-// 		this.__filters.push((context) => context.is(updateName));
-// 		return this;
-// 	},
-// };

package/dist/plugin.d.ts

@@ -1,218 +0,0 @@
-import type { Context, ContextType, MaybeArray, UpdateName } from "@gramio/contexts";
-import type { APIMethods } from "@gramio/types";
-import type { Bot } from "./bot";
-import { Composer } from "./composer";
-import type { AnyBot, DeriveDefinitions, ErrorDefinitions, Handler, Hooks } from "./types";
-/**
- * `Plugin` is an object  from which you can extends in Bot instance and adopt types
- *
- * @example
- * ```ts
- * import { Plugin, Bot } from "gramio";
- *
- * export class PluginError extends Error {
- *     wow: "type" | "safe" = "type";
- * }
- *
- * const plugin = new Plugin("gramio-example")
- *     .error("PLUGIN", PluginError)
- *     .derive(() => {
- *         return {
- *             some: ["derived", "props"] as const,
- *         };
- *     });
- *
- * const bot = new Bot(process.env.TOKEN!)
- *     .extend(plugin)
- *     .onError(({ context, kind, error }) => {
- *         if (context.is("message") && kind === "PLUGIN") {
- *             console.log(error.wow);
- *         }
- *     })
- *     .use((context) => {
- *         console.log(context.some);
- *     });
- * ```
- */
-export declare class Plugin<Errors extends ErrorDefinitions = {}, Derives extends DeriveDefinitions = DeriveDefinitions> {
-    /**
-     * 	@internal
-     * 	Set of Plugin data
-     *
-     *
-     */
-    _: {
-        /** Name of plugin */
-        name: string;
-        /** List of plugin dependencies. If user does't extend from listed there dependencies it throw a error */
-        dependencies: string[];
-        /** remap generic type. {} in runtime */
-        Errors: Errors;
-        /** remap generic type. {} in runtime */
-        Derives: Derives;
-        /**	Composer */
-        composer: Composer;
-        /** Store plugin preRequests hooks */
-        preRequests: [Hooks.PreRequest<any>, MaybeArray<keyof APIMethods> | undefined][];
-        /** Store plugin onResponses hooks */
-        onResponses: [Hooks.OnResponse<any>, MaybeArray<keyof APIMethods> | undefined][];
-        /** Store plugin onResponseErrors hooks */
-        onResponseErrors: [Hooks.OnResponseError<any>, MaybeArray<keyof APIMethods> | undefined][];
-        /**
-         * Store plugin groups
-         *
-         * If you use `on` or `use` in group and on plugin-level groups handlers are registered after plugin-level handlers
-         *  */
-        groups: ((bot: AnyBot) => AnyBot)[];
-        /** Store plugin onStarts hooks */
-        onStarts: Hooks.OnStart[];
-        /** Store plugin onStops hooks */
-        onStops: Hooks.OnStop[];
-        /** Store plugin onErrors hooks */
-        onErrors: Hooks.OnError<any, any>[];
-        /** Map of plugin errors */
-        errorsDefinitions: Record<string, {
-            new (...args: any): any;
-            prototype: Error;
-        }>;
-        decorators: Record<string, unknown>;
-    };
-    /** Create new Plugin. Please provide `name` */
-    constructor(name: string, { dependencies }?: {
-        dependencies?: string[];
-    });
-    /** Currently not isolated!!!
-     *
-     * > [!WARNING]
-     * > If you use `on` or `use` in a `group` and at the plugin level, the group handlers are registered **after** the handlers at the plugin level
-     */
-    group(grouped: (bot: Bot<Errors, Derives>) => AnyBot): this;
-    /**
-     * Register custom class-error in plugin
-     **/
-    error<Name extends string, NewError extends {
-        new (...args: any): any;
-        prototype: Error;
-    }>(kind: Name, error: NewError): Plugin<Errors & { [name in Name]: InstanceType<NewError>; }, Derives>;
-    /**
-     * Derive some data to handlers
-     *
-     * @example
-     * ```ts
-     * new Bot("token").derive((context) => {
-     * 		return {
-     * 			superSend: () => context.send("Derived method")
-     * 		}
-     * })
-     * ```
-     */
-    derive<Handler extends Hooks.Derive<Context<AnyBot>>>(handler: Handler): Plugin<Errors, Derives & {
-        global: Awaited<ReturnType<Handler>>;
-    }>;
-    derive<Update extends UpdateName, Handler extends Hooks.Derive<ContextType<AnyBot, Update>>>(updateName: MaybeArray<Update>, handler: Handler): Plugin<Errors, Derives & {
-        [K in Update]: Awaited<ReturnType<Handler>>;
-    }>;
-    decorate<Value extends Record<string, any>>(value: Value): Plugin<Errors, Derives & {
-        global: {
-            [K in keyof Value]: Value[K];
-        };
-    }>;
-    decorate<Name extends string, Value>(name: Name, value: Value): Plugin<Errors, Derives & {
-        global: {
-            [K in Name]: Value;
-        };
-    }>;
-    /** Register handler to one or many Updates */
-    on<T extends UpdateName>(updateName: MaybeArray<T>, handler: Handler<ContextType<AnyBot, T> & Derives["global"] & Derives[T]>): this;
-    /** Register handler to any Updates */
-    use(handler: Handler<Context<AnyBot> & Derives["global"]>): this;
-    /**
-     * This hook called before sending a request to Telegram Bot API (allows us to impact the sent parameters).
-     *
-     * @example
-     * ```typescript
-     * import { Bot } from "gramio";
-     *
-     * const bot = new Bot(process.env.TOKEN!).preRequest((context) => {
-     *     if (context.method === "sendMessage") {
-     *         context.params.text = "mutate params";
-     *     }
-     *
-     *     return context;
-     * });
-     *
-     * bot.start();
-     * ```
-     *
-     * [Documentation](https://gramio.dev/hooks/pre-request.html)
-     *  */
-    preRequest<Methods extends keyof APIMethods, Handler extends Hooks.PreRequest<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
-    preRequest(handler: Hooks.PreRequest): this;
-    /**
-     * This hook called when API return successful response
-     *
-     * [Documentation](https://gramio.dev/hooks/on-response.html)
-     * */
-    onResponse<Methods extends keyof APIMethods, Handler extends Hooks.OnResponse<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
-    onResponse(handler: Hooks.OnResponse): this;
-    /**
-     * This hook called when API return an error
-     *
-     * [Documentation](https://gramio.dev/hooks/on-response-error.html)
-     * */
-    onResponseError<Methods extends keyof APIMethods, Handler extends Hooks.OnResponseError<Methods>>(methods: MaybeArray<Methods>, handler: Handler): this;
-    onResponseError(handler: Hooks.OnResponseError): this;
-    /**
-     * This hook called when the bot is `started`.
-     *
-     * @example
-     * ```typescript
-     * import { Bot } from "gramio";
-     *
-     * const bot = new Bot(process.env.TOKEN!).onStart(
-     *     ({ plugins, info, updatesFrom }) => {
-     *         console.log(`plugin list - ${plugins.join(", ")}`);
-     *         console.log(`bot username is @${info.username}`);
-     * 		   console.log(`updates from ${updatesFrom}`);
-     *     }
-     * );
-     *
-     * bot.start();
-     * ```
-     *
-     * [Documentation](https://gramio.dev/hooks/on-start.html)
-     *  */
-    onStart(handler: Hooks.OnStart): this;
-    /**
-     * This hook called when the bot stops.
-     *
-     * @example
-     * ```typescript
-     * import { Bot } from "gramio";
-     *
-     * const bot = new Bot(process.env.TOKEN!).onStop(
-     *     ({ plugins, info, updatesFrom }) => {
-     *         console.log(`plugin list - ${plugins.join(", ")}`);
-     *         console.log(`bot username is @${info.username}`);
-     *     }
-     * );
-     *
-     * bot.start();
-     * bot.stop();
-     * ```
-     *
-     * [Documentation](https://gramio.dev/hooks/on-stop.html)
-     *  */
-    onStop(handler: Hooks.OnStop): this;
-    /**
-     * Set error handler.
-     * @example
-     * ```ts
-     * bot.onError("message", ({ context, kind, error }) => {
-     * 	return context.send(`${kind}: ${error.message}`);
-     * })
-     * ```
-     */
-    onError<T extends UpdateName>(updateName: MaybeArray<T>, handler: Hooks.OnError<Errors, ContextType<Bot, T> & Derives["global"] & Derives[T]>): this;
-    onError(handler: Hooks.OnError<Errors, Context<AnyBot> & Derives["global"]>): this;
-}

package/dist/plugin.js

@@ -1,269 +0,0 @@
-"use strict";
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Plugin = void 0;
-const inspectable_1 = require("inspectable");
-const composer_1 = require("./composer");
-const errors_1 = require("./errors");
-/**
- * `Plugin` is an object  from which you can extends in Bot instance and adopt types
- *
- * @example
- * ```ts
- * import { Plugin, Bot } from "gramio";
- *
- * export class PluginError extends Error {
- *     wow: "type" | "safe" = "type";
- * }
- *
- * const plugin = new Plugin("gramio-example")
- *     .error("PLUGIN", PluginError)
- *     .derive(() => {
- *         return {
- *             some: ["derived", "props"] as const,
- *         };
- *     });
- *
- * const bot = new Bot(process.env.TOKEN!)
- *     .extend(plugin)
- *     .onError(({ context, kind, error }) => {
- *         if (context.is("message") && kind === "PLUGIN") {
- *             console.log(error.wow);
- *         }
- *     })
- *     .use((context) => {
- *         console.log(context.some);
- *     });
- * ```
- */
-let Plugin = (() => {
-    let _classDecorators = [(0, inspectable_1.Inspectable)({
-            serialize: (plugin) => ({
-                name: plugin._.name,
-                dependencies: plugin._.dependencies,
-            }),
-        })];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    var Plugin = class {
-        static { _classThis = this; }
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-            Plugin = _classThis = _classDescriptor.value;
-            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
-        }
-        /**
-         * 	@internal
-         * 	Set of Plugin data
-         *
-         *
-         */
-        _ = {
-            /** Name of plugin */
-            name: "",
-            /** List of plugin dependencies. If user does't extend from listed there dependencies it throw a error */
-            dependencies: [],
-            /** remap generic type. {} in runtime */
-            Errors: {},
-            /** remap generic type. {} in runtime */
-            Derives: {},
-            /**	Composer */
-            composer: new composer_1.Composer(),
-            /** Store plugin preRequests hooks */
-            preRequests: [],
-            /** Store plugin onResponses hooks */
-            onResponses: [],
-            /** Store plugin onResponseErrors hooks */
-            onResponseErrors: [],
-            /**
-             * Store plugin groups
-             *
-             * If you use `on` or `use` in group and on plugin-level groups handlers are registered after plugin-level handlers
-             *  */
-            groups: [],
-            /** Store plugin onStarts hooks */
-            onStarts: [],
-            /** Store plugin onStops hooks */
-            onStops: [],
-            /** Store plugin onErrors hooks */
-            onErrors: [],
-            /** Map of plugin errors */
-            errorsDefinitions: {},
-            decorators: {},
-        };
-        /** Create new Plugin. Please provide `name` */
-        constructor(name, { dependencies } = {}) {
-            this._.name = name;
-            if (dependencies)
-                this._.dependencies = dependencies;
-        }
-        /** Currently not isolated!!!
-         *
-         * > [!WARNING]
-         * > If you use `on` or `use` in a `group` and at the plugin level, the group handlers are registered **after** the handlers at the plugin level
-         */
-        group(grouped) {
-            this._.groups.push(grouped);
-            return this;
-        }
-        /**
-         * Register custom class-error in plugin
-         **/
-        error(kind, error) {
-            //@ts-expect-error Set ErrorKind
-            error[errors_1.ErrorKind] = kind;
-            this._.errorsDefinitions[kind] = error;
-            return this;
-        }
-        derive(updateNameOrHandler, handler) {
-            this._.composer.derive(updateNameOrHandler, handler);
-            return this;
-        }
-        decorate(nameOrValue, value) {
-            if (typeof nameOrValue === "string")
-                this._.decorators[nameOrValue] = value;
-            else {
-                for (const [name, value] of Object.entries(nameOrValue)) {
-                    this._.decorators[name] = value;
-                }
-            }
-            return this;
-        }
-        /** Register handler to one or many Updates */
-        on(updateName, handler) {
-            this._.composer.on(updateName, handler);
-            return this;
-        }
-        /** Register handler to any Updates */
-        use(handler) {
-            this._.composer.use(handler);
-            return this;
-        }
-        preRequest(methodsOrHandler, handler) {
-            if ((typeof methodsOrHandler === "string" ||
-                Array.isArray(methodsOrHandler)) &&
-                handler)
-                this._.preRequests.push([handler, methodsOrHandler]);
-            else if (typeof methodsOrHandler === "function")
-                this._.preRequests.push([methodsOrHandler, undefined]);
-            return this;
-        }
-        onResponse(methodsOrHandler, handler) {
-            if ((typeof methodsOrHandler === "string" ||
-                Array.isArray(methodsOrHandler)) &&
-                handler)
-                this._.onResponses.push([handler, methodsOrHandler]);
-            else if (typeof methodsOrHandler === "function")
-                this._.onResponses.push([methodsOrHandler, undefined]);
-            return this;
-        }
-        onResponseError(methodsOrHandler, handler) {
-            if ((typeof methodsOrHandler === "string" ||
-                Array.isArray(methodsOrHandler)) &&
-                handler)
-                this._.onResponseErrors.push([handler, methodsOrHandler]);
-            else if (typeof methodsOrHandler === "function")
-                this._.onResponseErrors.push([methodsOrHandler, undefined]);
-            return this;
-        }
-        /**
-         * This hook called when the bot is `started`.
-         *
-         * @example
-         * ```typescript
-         * import { Bot } from "gramio";
-         *
-         * const bot = new Bot(process.env.TOKEN!).onStart(
-         *     ({ plugins, info, updatesFrom }) => {
-         *         console.log(`plugin list - ${plugins.join(", ")}`);
-         *         console.log(`bot username is @${info.username}`);
-         * 		   console.log(`updates from ${updatesFrom}`);
-         *     }
-         * );
-         *
-         * bot.start();
-         * ```
-         *
-         * [Documentation](https://gramio.dev/hooks/on-start.html)
-         *  */
-        onStart(handler) {
-            this._.onStarts.push(handler);
-            return this;
-        }
-        /**
-         * This hook called when the bot stops.
-         *
-         * @example
-         * ```typescript
-         * import { Bot } from "gramio";
-         *
-         * const bot = new Bot(process.env.TOKEN!).onStop(
-         *     ({ plugins, info, updatesFrom }) => {
-         *         console.log(`plugin list - ${plugins.join(", ")}`);
-         *         console.log(`bot username is @${info.username}`);
-         *     }
-         * );
-         *
-         * bot.start();
-         * bot.stop();
-         * ```
-         *
-         * [Documentation](https://gramio.dev/hooks/on-stop.html)
-         *  */
-        onStop(handler) {
-            this._.onStops.push(handler);
-            return this;
-        }
-        onError(updateNameOrHandler, handler) {
-            if (typeof updateNameOrHandler === "function") {
-                this._.onErrors.push(updateNameOrHandler);
-                return this;
-            }
-            if (handler) {
-                this._.onErrors.push(async (errContext) => {
-                    if (errContext.context.is(updateNameOrHandler))
-                        await handler(errContext);
-                });
-            }
-            return this;
-        }
-    };
-    return Plugin = _classThis;
-})();
-exports.Plugin = Plugin;