@frogbotai/piece-telegram-bot 0.22.0 → 0.23.0

package/dist/index.d.ts

@@ -1,46 +1,1321 @@
-import { type PieceFactoryConfig } from 'frogbot/pieces';
-export declare const telegramBotActions: readonly ["send_text_message", "send_media", "send_document", "send_location", "edit_message_text", "get_chat"];
+import type { z } from 'zod';
+import { createTelegramBotClient, type TelegramBotClient } from './client.js';
+import { verifyTelegramWebhook } from './webhook.js';
+export declare const telegramBotActions: readonly ["sendTextMessage", "sendMedia", "sendDocument", "sendAudio", "sendLocation", "sendMediaGroup", "sendPoll", "sendChatAction", "editMessageText", "deleteMessage", "forwardMessage", "pinMessage", "unpinMessage", "getChat", "getChatMember", "getFile", "createInviteLink", "answerCallbackQuery", "customApiCall"];
+export declare const telegramBotTriggers: readonly ["newUpdate"];
 export declare const telegramBotScopes: readonly [];
-export declare function createTelegramBot(config?: PieceFactoryConfig): import("frogbot/pieces").Piece & {
-    /** Send Text Message: Send a text message through a Telegram bot */
-    sendTextMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Media: Send a media message (photo, video, sticker, GIF) through a Telegram bot */
-    sendMedia: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Document: Send a generic file (document) to a Telegram chat */
-    sendDocument: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Audio: Send an audio file to a Telegram chat (.MP3/.M4A — shown in the music player) */
-    sendAudio: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Location: Send a geographic location (latitude/longitude) to a Telegram chat */
-    sendLocation: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Media Group: Send a group of 2–10 photos, videos, documents or audios as an album to a chat */
-    sendMediaGroup: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Poll: Send a native Telegram poll (regular or quiz) to a chat */
-    sendPoll: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Chat Action: Show a status (typing, uploading photo, recording voice, etc.) on behalf of the bot in a chat. The status is shown for up to 5 seconds. */
-    sendChatAction: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Edit Message Text: Edit the text of a previously sent message or an inline message */
-    editMessageText: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Delete Message: Delete a message sent in a chat. Bots can delete their own messages and messages in groups where they are admins. */
-    deleteMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Forward Message: Forward a message from one chat to another */
-    forwardMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Pin Message: Pin a message in a chat. The bot must be an administrator in the chat for this to work. */
-    pinMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Unpin Message: Unpin a message in a chat. Leave Message Id empty to unpin the most recent pinned message. */
-    unpinMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Get Chat: Get up-to-date information about a chat (name, description, photo, member count, etc.) */
-    getChat: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Get Chat Member: Get member info (or null) for the provided chat id and user id */
-    getChatMember: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Get File: Get file information and optionally download a file from Telegram */
-    getFile: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Create Invite Link: Create an invite link for a chat */
-    createInviteLink: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Answer Callback Query: Respond to a callback query sent by an inline keyboard button. Shows a notification or alert to the user. */
-    answerCallbackQuery: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Request Approval Message: Send an approval message to a chat and wait until the message is approved or disapproved */
-    requestApprovalMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Custom API Call: Make a custom API call to a specific endpoint */
-    customApiCall: import("node_modules/frogbot/dist/tools/types").AnyTool;
-};
+export declare const createTelegramBot: import("frogbot").PieceFactory<{
+    readonly slug: "telegramBot";
+    readonly label: "Telegram Bot";
+    readonly admin: {
+        readonly description: "Build chatbots and respond to Telegram updates";
+        readonly group: "Communication";
+    };
+    readonly auth: z.ZodObject<{
+        botToken: z.ZodString;
+    }, z.core.$strip>;
+    readonly options: z.ZodObject<{
+        webhookSecret: z.ZodOptional<z.ZodString>;
+        botUsername: z.ZodOptional<z.ZodString>;
+        allowedUserIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    readonly client: typeof createTelegramBotClient;
+    readonly webhook: {
+        verify: typeof verifyTelegramWebhook;
+        parse(): {
+            event: string;
+        };
+    };
+    readonly channel: {
+        adapter({ auth, options }: {
+            auth: {
+                botToken: string;
+            };
+            options: {
+                webhookSecret?: string | undefined;
+                botUsername?: string | undefined;
+                allowedUserIds?: string[] | undefined;
+            };
+        }): import("@chat-adapter/telegram").TelegramAdapter;
+        identity(): Promise<null>;
+    };
+    readonly actions: readonly [import("frogbot").PieceActionDefinition<z.ZodObject<{
+        replyToMessageId: z.ZodOptional<z.ZodNumber>;
+        replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+        messageThreadId: z.ZodOptional<z.ZodNumber>;
+        disableNotification: z.ZodDefault<z.ZodBoolean>;
+        protectContent: z.ZodDefault<z.ZodBoolean>;
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        message: z.ZodString;
+        parseMode: z.ZodDefault<z.ZodEnum<{
+            MarkdownV2: "MarkdownV2";
+            HTML: "HTML";
+            None: "None";
+        }>>;
+        disableWebPagePreview: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, {
+        run({ client, input, req }: import("frogbot").PieceRunArgs<{
+            [x: string]: unknown;
+        }, object, TelegramBotClient>): Promise<{
+            [x: string]: unknown;
+            ok: true;
+            result?: unknown;
+        }>;
+        slug: string;
+        label?: string;
+        description: string;
+        input: z.ZodObject<{
+            replyToMessageId: z.ZodOptional<z.ZodNumber>;
+            replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            messageThreadId: z.ZodOptional<z.ZodNumber>;
+            disableNotification: z.ZodDefault<z.ZodBoolean>;
+            protectContent: z.ZodDefault<z.ZodBoolean>;
+            chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            mediaType: z.ZodEnum<{
+                photo: "photo";
+                video: "video";
+                sticker: "sticker";
+                animation: "animation";
+            }>;
+            media: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>;
+            message: z.ZodOptional<z.ZodString>;
+            parseMode: z.ZodDefault<z.ZodEnum<{
+                MarkdownV2: "MarkdownV2";
+                HTML: "HTML";
+                None: "None";
+            }>>;
+        }, z.core.$strip>;
+        output?: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            result: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$loose> | undefined;
+        idempotent?: boolean;
+        options?: Partial<{
+            disableNotification: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            protectContent: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            chatId: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            mediaType: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            media: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            parseMode: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            replyToMessageId?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            replyMarkup?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            messageThreadId?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            message?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    mediaType: "photo" | "video" | "sticker" | "animation";
+                    media: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    message?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+        }> | undefined;
+    }, {
+        run({ client, input, req }: import("frogbot").PieceRunArgs<{
+            [x: string]: unknown;
+        }, object, TelegramBotClient>): Promise<{
+            [x: string]: unknown;
+            ok: true;
+            result?: unknown;
+        }>;
+        slug: string;
+        label?: string;
+        description: string;
+        input: z.ZodObject<{
+            replyToMessageId: z.ZodOptional<z.ZodNumber>;
+            replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            messageThreadId: z.ZodOptional<z.ZodNumber>;
+            disableNotification: z.ZodDefault<z.ZodBoolean>;
+            protectContent: z.ZodDefault<z.ZodBoolean>;
+            chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            document: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>;
+            caption: z.ZodOptional<z.ZodString>;
+            parseMode: z.ZodDefault<z.ZodEnum<{
+                MarkdownV2: "MarkdownV2";
+                HTML: "HTML";
+                None: "None";
+            }>>;
+        }, z.core.$strip>;
+        output?: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            result: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$loose> | undefined;
+        idempotent?: boolean;
+        options?: Partial<{
+            disableNotification: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    document: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            protectContent: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    document: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            chatId: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    document: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            document: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    document: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            parseMode: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    document: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            replyToMessageId?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    document: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            replyMarkup?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    document: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            messageThreadId?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    document: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            caption?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    document: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+        }> | undefined;
+    }, {
+        run({ client, input, req }: import("frogbot").PieceRunArgs<{
+            [x: string]: unknown;
+        }, object, TelegramBotClient>): Promise<{
+            [x: string]: unknown;
+            ok: true;
+            result?: unknown;
+        }>;
+        slug: string;
+        label?: string;
+        description: string;
+        input: z.ZodObject<{
+            replyToMessageId: z.ZodOptional<z.ZodNumber>;
+            replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            messageThreadId: z.ZodOptional<z.ZodNumber>;
+            disableNotification: z.ZodDefault<z.ZodBoolean>;
+            protectContent: z.ZodDefault<z.ZodBoolean>;
+            chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            audio: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>;
+            caption: z.ZodOptional<z.ZodString>;
+            parseMode: z.ZodDefault<z.ZodEnum<{
+                MarkdownV2: "MarkdownV2";
+                HTML: "HTML";
+                None: "None";
+            }>>;
+            duration: z.ZodOptional<z.ZodNumber>;
+            performer: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+            thumbnail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        output?: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            result: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$loose> | undefined;
+        idempotent?: boolean;
+        options?: Partial<{
+            disableNotification: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            protectContent: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            chatId: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            audio: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            parseMode: (args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>;
+            replyToMessageId?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            replyMarkup?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            messageThreadId?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            caption?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            duration?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            performer?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            title?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+            thumbnail?: ((args: {
+                input: Partial<{
+                    disableNotification: boolean;
+                    protectContent: boolean;
+                    chatId: string | number;
+                    audio: string | {
+                        fileId: string | number;
+                        name?: string | undefined;
+                    };
+                    parseMode: "MarkdownV2" | "HTML" | "None";
+                    replyToMessageId?: number | undefined;
+                    replyMarkup?: Record<string, unknown> | undefined;
+                    messageThreadId?: number | undefined;
+                    caption?: string | undefined;
+                    duration?: number | undefined;
+                    performer?: string | undefined;
+                    title?: string | undefined;
+                    thumbnail?: string | undefined;
+                }>;
+                client: {
+                    fileUrl(path: string): string;
+                    call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+                    request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+                    downloadFile(path: string): Promise<string>;
+                };
+                options: object;
+                req: import("frogbot").FrogbotRequest;
+            }) => Promise<import("frogbot").PieceOption[]>) | undefined;
+        }> | undefined;
+    }, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        replyToMessageId: z.ZodOptional<z.ZodNumber>;
+        replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+        messageThreadId: z.ZodOptional<z.ZodNumber>;
+        disableNotification: z.ZodDefault<z.ZodBoolean>;
+        protectContent: z.ZodDefault<z.ZodBoolean>;
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        latitude: z.ZodNumber;
+        longitude: z.ZodNumber;
+        horizontalAccuracy: z.ZodOptional<z.ZodNumber>;
+        livePeriod: z.ZodOptional<z.ZodNumber>;
+        heading: z.ZodOptional<z.ZodNumber>;
+        proximityAlertRadius: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        messageThreadId: z.ZodOptional<z.ZodNumber>;
+        disableNotification: z.ZodDefault<z.ZodBoolean>;
+        protectContent: z.ZodDefault<z.ZodBoolean>;
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        media: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                photo: "photo";
+                video: "video";
+                document: "document";
+                audio: "audio";
+            }>;
+            media: z.ZodString;
+            caption: z.ZodOptional<z.ZodString>;
+            parseMode: z.ZodOptional<z.ZodEnum<{
+                MarkdownV2: "MarkdownV2";
+                HTML: "HTML";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        replyToMessageId: z.ZodOptional<z.ZodNumber>;
+        replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+        messageThreadId: z.ZodOptional<z.ZodNumber>;
+        disableNotification: z.ZodDefault<z.ZodBoolean>;
+        protectContent: z.ZodDefault<z.ZodBoolean>;
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        question: z.ZodString;
+        options: z.ZodArray<z.ZodString>;
+        isAnonymous: z.ZodDefault<z.ZodBoolean>;
+        type: z.ZodDefault<z.ZodEnum<{
+            regular: "regular";
+            quiz: "quiz";
+        }>>;
+        allowsMultipleAnswers: z.ZodDefault<z.ZodBoolean>;
+        correctOptionId: z.ZodOptional<z.ZodNumber>;
+        explanation: z.ZodOptional<z.ZodString>;
+        explanationParseMode: z.ZodOptional<z.ZodEnum<{
+            MarkdownV2: "MarkdownV2";
+            HTML: "HTML";
+        }>>;
+        openPeriod: z.ZodOptional<z.ZodNumber>;
+        closeDate: z.ZodOptional<z.ZodNumber>;
+        isClosed: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        messageThreadId: z.ZodOptional<z.ZodNumber>;
+        action: z.ZodEnum<{
+            typing: "typing";
+            upload_photo: "upload_photo";
+            record_video: "record_video";
+            upload_video: "upload_video";
+            record_voice: "record_voice";
+            upload_voice: "upload_voice";
+            upload_document: "upload_document";
+            choose_sticker: "choose_sticker";
+            find_location: "find_location";
+            record_video_note: "record_video_note";
+            upload_video_note: "upload_video_note";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        chatId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        messageId: z.ZodOptional<z.ZodNumber>;
+        inlineMessageId: z.ZodOptional<z.ZodString>;
+        text: z.ZodString;
+        parseMode: z.ZodDefault<z.ZodEnum<{
+            MarkdownV2: "MarkdownV2";
+            HTML: "HTML";
+            None: "None";
+        }>>;
+        replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        messageId: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        messageThreadId: z.ZodOptional<z.ZodNumber>;
+        disableNotification: z.ZodDefault<z.ZodBoolean>;
+        protectContent: z.ZodDefault<z.ZodBoolean>;
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        fromChatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        messageId: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        messageId: z.ZodNumber;
+        disableNotification: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        messageId: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        userId: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, {
+        slug: string;
+        description: string;
+        input: z.ZodObject<{
+            fileId: z.ZodString;
+            download: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+        output: z.ZodObject<{
+            fileInfo: z.ZodObject<{
+                file_id: z.ZodString;
+                file_unique_id: z.ZodString;
+                file_size: z.ZodOptional<z.ZodNumber>;
+                file_path: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
+            fileUrl: z.ZodOptional<z.ZodString>;
+            fileContentBase64: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        idempotent: boolean;
+        run({ client, input, }: import("frogbot").PieceRunArgs<{
+            fileId: string;
+            download: boolean;
+        }, object, TelegramBotClient>): Promise<{
+            fileInfo: {
+                [x: string]: unknown;
+                file_id: string;
+                file_unique_id: string;
+                file_size?: number | undefined;
+                file_path?: string | undefined;
+            };
+            fileUrl: string | undefined;
+            fileContentBase64: string | undefined;
+        }>;
+    }, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        name: z.ZodOptional<z.ZodString>;
+        expireDate: z.ZodOptional<z.ZodNumber>;
+        memberLimit: z.ZodOptional<z.ZodNumber>;
+        createsJoinRequest: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
+        callbackQueryId: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
+        showAlert: z.ZodDefault<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+        cacheTime: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        result: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>, {
+        slug: string;
+        description: string;
+        input: z.ZodObject<{
+            method: z.ZodDefault<z.ZodEnum<{
+                POST: "POST";
+                GET: "GET";
+                PUT: "PUT";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+            }>>;
+            endpoint: z.ZodString;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            body: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        }, z.core.$strip>;
+        output: z.ZodUnknown;
+        idempotent: boolean;
+        run({ client, input, }: import("frogbot").PieceRunArgs<z.output<z.ZodObject<{
+            method: z.ZodDefault<z.ZodEnum<{
+                POST: "POST";
+                GET: "GET";
+                PUT: "PUT";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+            }>>;
+            endpoint: z.ZodString;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            body: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        }, z.core.$strip>>, object, TelegramBotClient>): Promise<unknown>;
+    }];
+    readonly triggers: readonly [import("frogbot").PieceAppTrigger<z.ZodObject<{
+        updateTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            message: "message";
+            edited_message: "edited_message";
+            channel_post: "channel_post";
+            edited_channel_post: "edited_channel_post";
+            callback_query: "callback_query";
+            inline_query: "inline_query";
+            chosen_inline_result: "chosen_inline_result";
+            poll: "poll";
+            poll_answer: "poll_answer";
+            my_chat_member: "my_chat_member";
+            chat_member: "chat_member";
+            chat_join_request: "chat_join_request";
+        }>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        update_id: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$catchall<z.ZodType<import("frogbot").PieceJSON, unknown, z.core.$ZodTypeInternals<import("frogbot").PieceJSON, unknown>>>>, object, {
+        fileUrl(path: string): string;
+        call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
+        request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
+        downloadFile(path: string): Promise<string>;
+    }>];
+}>;
 //# sourceMappingURL=index.d.ts.map