@frogbotai/piece-telegram-bot 0.21.0 → 0.23.0

package/dist/actions/index.d.ts

@@ -0,0 +1,1274 @@
+import type { PieceActionDefinition, PieceRunArgs } from 'frogbot/pieces';
+import { z } from 'zod';
+import type { TelegramBotClient } from '../client.js';
+type Input = Record<string, unknown>;
+export declare const sendTextMessage: 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>;
+}>;
+export declare const sendMedia: {
+    run({ client, input, req }: PieceRunArgs<Input, 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;
+};
+export declare const sendDocument: {
+    run({ client, input, req }: PieceRunArgs<Input, 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;
+};
+export declare const sendAudio: {
+    run({ client, input, req }: PieceRunArgs<Input, 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;
+};
+export declare const sendLocation: 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>;
+}>;
+export declare const sendMediaGroup: 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>;
+}>;
+export declare const sendPoll: 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>;
+}>;
+export declare const sendChatAction: 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>;
+}>;
+export declare const editMessageText: 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>;
+}>;
+export declare const deleteMessage: 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>;
+}>;
+export declare const forwardMessage: 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>;
+}>;
+export declare const pinMessage: 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>;
+}>;
+export declare const unpinMessage: 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>;
+}>;
+export declare const getChat: 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>;
+}>;
+export declare const getChatMember: 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>;
+}>;
+export declare const getFile: {
+    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, }: 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;
+    }>;
+};
+export declare const createInviteLink: 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>;
+}>;
+export declare const answerCallbackQuery: 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>;
+}>;
+declare const customInput: 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>;
+export declare const customApiCall: {
+    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, }: PieceRunArgs<z.output<typeof customInput>, object, TelegramBotClient>): Promise<unknown>;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map