@frogbotai/piece-telegram-bot 0.27.0 → 0.28.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (17) hide show
  1. package/dist/actions/index.d.ts +341 -1040
  2. package/dist/actions/index.d.ts.map +1 -1
  3. package/dist/actions/index.js +66 -51
  4. package/dist/actions/index.js.map +1 -1
  5. package/dist/config.d.ts +1 -0
  6. package/dist/config.d.ts.map +1 -1
  7. package/dist/define.d.ts +68 -0
  8. package/dist/define.d.ts.map +1 -0
  9. package/dist/define.js +3 -0
  10. package/dist/define.js.map +1 -0
  11. package/dist/index.d.ts +378 -1053
  12. package/dist/index.d.ts.map +1 -1
  13. package/dist/triggers/newUpdate.d.ts +49 -23
  14. package/dist/triggers/newUpdate.d.ts.map +1 -1
  15. package/dist/triggers/newUpdate.js +3 -2
  16. package/dist/triggers/newUpdate.js.map +1 -1
  17. package/package.json +3 -3
package/dist/index.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  import type { z } from 'zod';
2
- import { createTelegramBotClient, type TelegramBotClient } from './client.js';
2
+ import { createTelegramBotClient } from './client.js';
3
3
  import { verifyTelegramWebhook } from './webhook.js';
4
4
  export declare const telegramBotActions: readonly ["sendTextMessage", "sendMedia", "sendDocument", "sendAudio", "sendLocation", "sendMediaGroup", "sendPoll", "sendChatAction", "editMessageText", "deleteMessage", "forwardMessage", "pinMessage", "unpinMessage", "getChat", "getChatMember", "getFile", "createInviteLink", "answerCallbackQuery", "customApiCall"];
5
5
  export declare const telegramBotTriggers: readonly ["newUpdate"];
@@ -62,959 +62,136 @@ export declare const createTelegramBot: import("frogbot").PieceFactory<{
62
62
  }, z.core.$strip>, z.ZodObject<{
63
63
  ok: z.ZodLiteral<true>;
64
64
  result: z.ZodOptional<z.ZodUnknown>;
65
- }, z.core.$loose>, object, {
65
+ }, z.core.$loose>, {
66
+ webhookSecret?: string | undefined;
67
+ botUsername?: string | undefined;
68
+ allowedUserIds?: string[] | undefined;
69
+ }, {
66
70
  fileUrl(path: string): string;
67
71
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
68
72
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
69
73
  downloadFile(path: string): Promise<string>;
70
- }>, {
71
- run({ client, input, req }: import("frogbot").PieceRunArgs<{
72
- [x: string]: unknown;
73
- }, object, TelegramBotClient>): Promise<{
74
- [x: string]: unknown;
75
- ok: true;
76
- result?: unknown;
77
- }>;
78
- slug: string;
79
- label?: string;
80
- description: string;
81
- input: z.ZodObject<{
82
- replyToMessageId: z.ZodOptional<z.ZodNumber>;
83
- replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
84
- messageThreadId: z.ZodOptional<z.ZodNumber>;
85
- disableNotification: z.ZodDefault<z.ZodBoolean>;
86
- protectContent: z.ZodDefault<z.ZodBoolean>;
87
- chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
88
- mediaType: z.ZodEnum<{
89
- animation: "animation";
90
- photo: "photo";
91
- sticker: "sticker";
92
- video: "video";
93
- }>;
94
- media: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
95
- fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
96
- name: z.ZodOptional<z.ZodString>;
97
- }, z.core.$strip>]>;
98
- message: z.ZodOptional<z.ZodString>;
99
- parseMode: z.ZodDefault<z.ZodEnum<{
100
- MarkdownV2: "MarkdownV2";
101
- HTML: "HTML";
102
- None: "None";
103
- }>>;
104
- }, z.core.$strip>;
105
- output?: z.ZodObject<{
106
- ok: z.ZodLiteral<true>;
107
- result: z.ZodOptional<z.ZodUnknown>;
108
- }, z.core.$loose> | undefined;
109
- idempotent?: boolean;
110
- options?: Partial<{
111
- disableNotification: (args: {
112
- input: Partial<{
113
- disableNotification: boolean;
114
- protectContent: boolean;
115
- chatId: string | number;
116
- mediaType: "animation" | "photo" | "sticker" | "video";
117
- media: string | {
118
- fileId: string | number;
119
- name?: string | undefined;
120
- };
121
- parseMode: "MarkdownV2" | "HTML" | "None";
122
- replyToMessageId?: number | undefined;
123
- replyMarkup?: Record<string, unknown> | undefined;
124
- messageThreadId?: number | undefined;
125
- message?: string | undefined;
126
- }>;
127
- client: {
128
- fileUrl(path: string): string;
129
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
130
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
131
- downloadFile(path: string): Promise<string>;
132
- };
133
- options: object;
134
- req: import("frogbot").FrogBotRequest;
135
- }) => Promise<import("frogbot").PieceOption[]>;
136
- protectContent: (args: {
137
- input: Partial<{
138
- disableNotification: boolean;
139
- protectContent: boolean;
140
- chatId: string | number;
141
- mediaType: "animation" | "photo" | "sticker" | "video";
142
- media: string | {
143
- fileId: string | number;
144
- name?: string | undefined;
145
- };
146
- parseMode: "MarkdownV2" | "HTML" | "None";
147
- replyToMessageId?: number | undefined;
148
- replyMarkup?: Record<string, unknown> | undefined;
149
- messageThreadId?: number | undefined;
150
- message?: string | undefined;
151
- }>;
152
- client: {
153
- fileUrl(path: string): string;
154
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
155
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
156
- downloadFile(path: string): Promise<string>;
157
- };
158
- options: object;
159
- req: import("frogbot").FrogBotRequest;
160
- }) => Promise<import("frogbot").PieceOption[]>;
161
- chatId: (args: {
162
- input: Partial<{
163
- disableNotification: boolean;
164
- protectContent: boolean;
165
- chatId: string | number;
166
- mediaType: "animation" | "photo" | "sticker" | "video";
167
- media: string | {
168
- fileId: string | number;
169
- name?: string | undefined;
170
- };
171
- parseMode: "MarkdownV2" | "HTML" | "None";
172
- replyToMessageId?: number | undefined;
173
- replyMarkup?: Record<string, unknown> | undefined;
174
- messageThreadId?: number | undefined;
175
- message?: string | undefined;
176
- }>;
177
- client: {
178
- fileUrl(path: string): string;
179
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
180
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
181
- downloadFile(path: string): Promise<string>;
182
- };
183
- options: object;
184
- req: import("frogbot").FrogBotRequest;
185
- }) => Promise<import("frogbot").PieceOption[]>;
186
- mediaType: (args: {
187
- input: Partial<{
188
- disableNotification: boolean;
189
- protectContent: boolean;
190
- chatId: string | number;
191
- mediaType: "animation" | "photo" | "sticker" | "video";
192
- media: string | {
193
- fileId: string | number;
194
- name?: string | undefined;
195
- };
196
- parseMode: "MarkdownV2" | "HTML" | "None";
197
- replyToMessageId?: number | undefined;
198
- replyMarkup?: Record<string, unknown> | undefined;
199
- messageThreadId?: number | undefined;
200
- message?: string | undefined;
201
- }>;
202
- client: {
203
- fileUrl(path: string): string;
204
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
205
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
206
- downloadFile(path: string): Promise<string>;
207
- };
208
- options: object;
209
- req: import("frogbot").FrogBotRequest;
210
- }) => Promise<import("frogbot").PieceOption[]>;
211
- media: (args: {
212
- input: Partial<{
213
- disableNotification: boolean;
214
- protectContent: boolean;
215
- chatId: string | number;
216
- mediaType: "animation" | "photo" | "sticker" | "video";
217
- media: string | {
218
- fileId: string | number;
219
- name?: string | undefined;
220
- };
221
- parseMode: "MarkdownV2" | "HTML" | "None";
222
- replyToMessageId?: number | undefined;
223
- replyMarkup?: Record<string, unknown> | undefined;
224
- messageThreadId?: number | undefined;
225
- message?: string | undefined;
226
- }>;
227
- client: {
228
- fileUrl(path: string): string;
229
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
230
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
231
- downloadFile(path: string): Promise<string>;
232
- };
233
- options: object;
234
- req: import("frogbot").FrogBotRequest;
235
- }) => Promise<import("frogbot").PieceOption[]>;
236
- parseMode: (args: {
237
- input: Partial<{
238
- disableNotification: boolean;
239
- protectContent: boolean;
240
- chatId: string | number;
241
- mediaType: "animation" | "photo" | "sticker" | "video";
242
- media: string | {
243
- fileId: string | number;
244
- name?: string | undefined;
245
- };
246
- parseMode: "MarkdownV2" | "HTML" | "None";
247
- replyToMessageId?: number | undefined;
248
- replyMarkup?: Record<string, unknown> | undefined;
249
- messageThreadId?: number | undefined;
250
- message?: string | undefined;
251
- }>;
252
- client: {
253
- fileUrl(path: string): string;
254
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
255
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
256
- downloadFile(path: string): Promise<string>;
257
- };
258
- options: object;
259
- req: import("frogbot").FrogBotRequest;
260
- }) => Promise<import("frogbot").PieceOption[]>;
261
- replyToMessageId?: ((args: {
262
- input: Partial<{
263
- disableNotification: boolean;
264
- protectContent: boolean;
265
- chatId: string | number;
266
- mediaType: "animation" | "photo" | "sticker" | "video";
267
- media: string | {
268
- fileId: string | number;
269
- name?: string | undefined;
270
- };
271
- parseMode: "MarkdownV2" | "HTML" | "None";
272
- replyToMessageId?: number | undefined;
273
- replyMarkup?: Record<string, unknown> | undefined;
274
- messageThreadId?: number | undefined;
275
- message?: string | undefined;
276
- }>;
277
- client: {
278
- fileUrl(path: string): string;
279
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
280
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
281
- downloadFile(path: string): Promise<string>;
282
- };
283
- options: object;
284
- req: import("frogbot").FrogBotRequest;
285
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
286
- replyMarkup?: ((args: {
287
- input: Partial<{
288
- disableNotification: boolean;
289
- protectContent: boolean;
290
- chatId: string | number;
291
- mediaType: "animation" | "photo" | "sticker" | "video";
292
- media: string | {
293
- fileId: string | number;
294
- name?: string | undefined;
295
- };
296
- parseMode: "MarkdownV2" | "HTML" | "None";
297
- replyToMessageId?: number | undefined;
298
- replyMarkup?: Record<string, unknown> | undefined;
299
- messageThreadId?: number | undefined;
300
- message?: string | undefined;
301
- }>;
302
- client: {
303
- fileUrl(path: string): string;
304
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
305
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
306
- downloadFile(path: string): Promise<string>;
307
- };
308
- options: object;
309
- req: import("frogbot").FrogBotRequest;
310
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
311
- messageThreadId?: ((args: {
312
- input: Partial<{
313
- disableNotification: boolean;
314
- protectContent: boolean;
315
- chatId: string | number;
316
- mediaType: "animation" | "photo" | "sticker" | "video";
317
- media: string | {
318
- fileId: string | number;
319
- name?: string | undefined;
320
- };
321
- parseMode: "MarkdownV2" | "HTML" | "None";
322
- replyToMessageId?: number | undefined;
323
- replyMarkup?: Record<string, unknown> | undefined;
324
- messageThreadId?: number | undefined;
325
- message?: string | undefined;
326
- }>;
327
- client: {
328
- fileUrl(path: string): string;
329
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
330
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
331
- downloadFile(path: string): Promise<string>;
332
- };
333
- options: object;
334
- req: import("frogbot").FrogBotRequest;
335
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
336
- message?: ((args: {
337
- input: Partial<{
338
- disableNotification: boolean;
339
- protectContent: boolean;
340
- chatId: string | number;
341
- mediaType: "animation" | "photo" | "sticker" | "video";
342
- media: string | {
343
- fileId: string | number;
344
- name?: string | undefined;
345
- };
346
- parseMode: "MarkdownV2" | "HTML" | "None";
347
- replyToMessageId?: number | undefined;
348
- replyMarkup?: Record<string, unknown> | undefined;
349
- messageThreadId?: number | undefined;
350
- message?: string | undefined;
351
- }>;
352
- client: {
353
- fileUrl(path: string): string;
354
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
355
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
356
- downloadFile(path: string): Promise<string>;
357
- };
358
- options: object;
359
- req: import("frogbot").FrogBotRequest;
360
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
361
- }> | undefined;
362
74
  }, {
363
- run({ client, input, req }: import("frogbot").PieceRunArgs<{
364
- [x: string]: unknown;
365
- }, object, TelegramBotClient>): Promise<{
366
- [x: string]: unknown;
367
- ok: true;
368
- result?: unknown;
75
+ [x: string]: unknown;
76
+ ok: true;
77
+ result?: unknown;
78
+ }> & {
79
+ slug: "sendTextMessage";
80
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
81
+ replyToMessageId: z.ZodOptional<z.ZodNumber>;
82
+ replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
83
+ messageThreadId: z.ZodOptional<z.ZodNumber>;
84
+ disableNotification: z.ZodDefault<z.ZodBoolean>;
85
+ protectContent: z.ZodDefault<z.ZodBoolean>;
86
+ chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
87
+ mediaType: z.ZodEnum<{
88
+ animation: "animation";
89
+ photo: "photo";
90
+ sticker: "sticker";
91
+ video: "video";
369
92
  }>;
370
- slug: string;
371
- label?: string;
372
- description: string;
373
- input: z.ZodObject<{
374
- replyToMessageId: z.ZodOptional<z.ZodNumber>;
375
- replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
376
- messageThreadId: z.ZodOptional<z.ZodNumber>;
377
- disableNotification: z.ZodDefault<z.ZodBoolean>;
378
- protectContent: z.ZodDefault<z.ZodBoolean>;
379
- chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
380
- document: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
381
- fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
382
- name: z.ZodOptional<z.ZodString>;
383
- }, z.core.$strip>]>;
384
- caption: z.ZodOptional<z.ZodString>;
385
- parseMode: z.ZodDefault<z.ZodEnum<{
386
- MarkdownV2: "MarkdownV2";
387
- HTML: "HTML";
388
- None: "None";
389
- }>>;
390
- }, z.core.$strip>;
391
- output?: z.ZodObject<{
392
- ok: z.ZodLiteral<true>;
393
- result: z.ZodOptional<z.ZodUnknown>;
394
- }, z.core.$loose> | undefined;
395
- idempotent?: boolean;
396
- options?: Partial<{
397
- disableNotification: (args: {
398
- input: Partial<{
399
- disableNotification: boolean;
400
- protectContent: boolean;
401
- chatId: string | number;
402
- document: string | {
403
- fileId: string | number;
404
- name?: string | undefined;
405
- };
406
- parseMode: "MarkdownV2" | "HTML" | "None";
407
- replyToMessageId?: number | undefined;
408
- replyMarkup?: Record<string, unknown> | undefined;
409
- messageThreadId?: number | undefined;
410
- caption?: string | undefined;
411
- }>;
412
- client: {
413
- fileUrl(path: string): string;
414
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
415
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
416
- downloadFile(path: string): Promise<string>;
417
- };
418
- options: object;
419
- req: import("frogbot").FrogBotRequest;
420
- }) => Promise<import("frogbot").PieceOption[]>;
421
- protectContent: (args: {
422
- input: Partial<{
423
- disableNotification: boolean;
424
- protectContent: boolean;
425
- chatId: string | number;
426
- document: string | {
427
- fileId: string | number;
428
- name?: string | undefined;
429
- };
430
- parseMode: "MarkdownV2" | "HTML" | "None";
431
- replyToMessageId?: number | undefined;
432
- replyMarkup?: Record<string, unknown> | undefined;
433
- messageThreadId?: number | undefined;
434
- caption?: string | undefined;
435
- }>;
436
- client: {
437
- fileUrl(path: string): string;
438
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
439
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
440
- downloadFile(path: string): Promise<string>;
441
- };
442
- options: object;
443
- req: import("frogbot").FrogBotRequest;
444
- }) => Promise<import("frogbot").PieceOption[]>;
445
- chatId: (args: {
446
- input: Partial<{
447
- disableNotification: boolean;
448
- protectContent: boolean;
449
- chatId: string | number;
450
- document: string | {
451
- fileId: string | number;
452
- name?: string | undefined;
453
- };
454
- parseMode: "MarkdownV2" | "HTML" | "None";
455
- replyToMessageId?: number | undefined;
456
- replyMarkup?: Record<string, unknown> | undefined;
457
- messageThreadId?: number | undefined;
458
- caption?: string | undefined;
459
- }>;
460
- client: {
461
- fileUrl(path: string): string;
462
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
463
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
464
- downloadFile(path: string): Promise<string>;
465
- };
466
- options: object;
467
- req: import("frogbot").FrogBotRequest;
468
- }) => Promise<import("frogbot").PieceOption[]>;
469
- document: (args: {
470
- input: Partial<{
471
- disableNotification: boolean;
472
- protectContent: boolean;
473
- chatId: string | number;
474
- document: string | {
475
- fileId: string | number;
476
- name?: string | undefined;
477
- };
478
- parseMode: "MarkdownV2" | "HTML" | "None";
479
- replyToMessageId?: number | undefined;
480
- replyMarkup?: Record<string, unknown> | undefined;
481
- messageThreadId?: number | undefined;
482
- caption?: string | undefined;
483
- }>;
484
- client: {
485
- fileUrl(path: string): string;
486
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
487
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
488
- downloadFile(path: string): Promise<string>;
489
- };
490
- options: object;
491
- req: import("frogbot").FrogBotRequest;
492
- }) => Promise<import("frogbot").PieceOption[]>;
493
- parseMode: (args: {
494
- input: Partial<{
495
- disableNotification: boolean;
496
- protectContent: boolean;
497
- chatId: string | number;
498
- document: string | {
499
- fileId: string | number;
500
- name?: string | undefined;
501
- };
502
- parseMode: "MarkdownV2" | "HTML" | "None";
503
- replyToMessageId?: number | undefined;
504
- replyMarkup?: Record<string, unknown> | undefined;
505
- messageThreadId?: number | undefined;
506
- caption?: string | undefined;
507
- }>;
508
- client: {
509
- fileUrl(path: string): string;
510
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
511
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
512
- downloadFile(path: string): Promise<string>;
513
- };
514
- options: object;
515
- req: import("frogbot").FrogBotRequest;
516
- }) => Promise<import("frogbot").PieceOption[]>;
517
- replyToMessageId?: ((args: {
518
- input: Partial<{
519
- disableNotification: boolean;
520
- protectContent: boolean;
521
- chatId: string | number;
522
- document: string | {
523
- fileId: string | number;
524
- name?: string | undefined;
525
- };
526
- parseMode: "MarkdownV2" | "HTML" | "None";
527
- replyToMessageId?: number | undefined;
528
- replyMarkup?: Record<string, unknown> | undefined;
529
- messageThreadId?: number | undefined;
530
- caption?: string | undefined;
531
- }>;
532
- client: {
533
- fileUrl(path: string): string;
534
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
535
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
536
- downloadFile(path: string): Promise<string>;
537
- };
538
- options: object;
539
- req: import("frogbot").FrogBotRequest;
540
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
541
- replyMarkup?: ((args: {
542
- input: Partial<{
543
- disableNotification: boolean;
544
- protectContent: boolean;
545
- chatId: string | number;
546
- document: string | {
547
- fileId: string | number;
548
- name?: string | undefined;
549
- };
550
- parseMode: "MarkdownV2" | "HTML" | "None";
551
- replyToMessageId?: number | undefined;
552
- replyMarkup?: Record<string, unknown> | undefined;
553
- messageThreadId?: number | undefined;
554
- caption?: string | undefined;
555
- }>;
556
- client: {
557
- fileUrl(path: string): string;
558
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
559
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
560
- downloadFile(path: string): Promise<string>;
561
- };
562
- options: object;
563
- req: import("frogbot").FrogBotRequest;
564
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
565
- messageThreadId?: ((args: {
566
- input: Partial<{
567
- disableNotification: boolean;
568
- protectContent: boolean;
569
- chatId: string | number;
570
- document: string | {
571
- fileId: string | number;
572
- name?: string | undefined;
573
- };
574
- parseMode: "MarkdownV2" | "HTML" | "None";
575
- replyToMessageId?: number | undefined;
576
- replyMarkup?: Record<string, unknown> | undefined;
577
- messageThreadId?: number | undefined;
578
- caption?: string | undefined;
579
- }>;
580
- client: {
581
- fileUrl(path: string): string;
582
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
583
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
584
- downloadFile(path: string): Promise<string>;
585
- };
586
- options: object;
587
- req: import("frogbot").FrogBotRequest;
588
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
589
- caption?: ((args: {
590
- input: Partial<{
591
- disableNotification: boolean;
592
- protectContent: boolean;
593
- chatId: string | number;
594
- document: string | {
595
- fileId: string | number;
596
- name?: string | undefined;
597
- };
598
- parseMode: "MarkdownV2" | "HTML" | "None";
599
- replyToMessageId?: number | undefined;
600
- replyMarkup?: Record<string, unknown> | undefined;
601
- messageThreadId?: number | undefined;
602
- caption?: string | undefined;
603
- }>;
604
- client: {
605
- fileUrl(path: string): string;
606
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
607
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
608
- downloadFile(path: string): Promise<string>;
609
- };
610
- options: object;
611
- req: import("frogbot").FrogBotRequest;
612
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
613
- }> | undefined;
93
+ media: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
94
+ fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
95
+ name: z.ZodOptional<z.ZodString>;
96
+ }, z.core.$strip>]>;
97
+ message: z.ZodOptional<z.ZodString>;
98
+ parseMode: z.ZodDefault<z.ZodEnum<{
99
+ MarkdownV2: "MarkdownV2";
100
+ HTML: "HTML";
101
+ None: "None";
102
+ }>>;
103
+ }, z.core.$strip>, z.ZodObject<{
104
+ ok: z.ZodLiteral<true>;
105
+ result: z.ZodOptional<z.ZodUnknown>;
106
+ }, z.core.$loose>, {
107
+ webhookSecret?: string | undefined;
108
+ botUsername?: string | undefined;
109
+ allowedUserIds?: string[] | undefined;
614
110
  }, {
615
- run({ client, input, req }: import("frogbot").PieceRunArgs<{
616
- [x: string]: unknown;
617
- }, object, TelegramBotClient>): Promise<{
618
- [x: string]: unknown;
619
- ok: true;
620
- result?: unknown;
621
- }>;
622
- slug: string;
623
- label?: string;
624
- description: string;
625
- input: z.ZodObject<{
626
- replyToMessageId: z.ZodOptional<z.ZodNumber>;
627
- replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
628
- messageThreadId: z.ZodOptional<z.ZodNumber>;
629
- disableNotification: z.ZodDefault<z.ZodBoolean>;
630
- protectContent: z.ZodDefault<z.ZodBoolean>;
631
- chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
632
- audio: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
633
- fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
634
- name: z.ZodOptional<z.ZodString>;
635
- }, z.core.$strip>]>;
636
- caption: z.ZodOptional<z.ZodString>;
637
- parseMode: z.ZodDefault<z.ZodEnum<{
638
- MarkdownV2: "MarkdownV2";
639
- HTML: "HTML";
640
- None: "None";
641
- }>>;
642
- duration: z.ZodOptional<z.ZodNumber>;
643
- performer: z.ZodOptional<z.ZodString>;
644
- title: z.ZodOptional<z.ZodString>;
645
- thumbnail: z.ZodOptional<z.ZodString>;
646
- }, z.core.$strip>;
647
- output?: z.ZodObject<{
648
- ok: z.ZodLiteral<true>;
649
- result: z.ZodOptional<z.ZodUnknown>;
650
- }, z.core.$loose> | undefined;
651
- idempotent?: boolean;
652
- options?: Partial<{
653
- disableNotification: (args: {
654
- input: Partial<{
655
- disableNotification: boolean;
656
- protectContent: boolean;
657
- chatId: string | number;
658
- audio: string | {
659
- fileId: string | number;
660
- name?: string | undefined;
661
- };
662
- parseMode: "MarkdownV2" | "HTML" | "None";
663
- replyToMessageId?: number | undefined;
664
- replyMarkup?: Record<string, unknown> | undefined;
665
- messageThreadId?: number | undefined;
666
- caption?: string | undefined;
667
- duration?: number | undefined;
668
- performer?: string | undefined;
669
- title?: string | undefined;
670
- thumbnail?: string | undefined;
671
- }>;
672
- client: {
673
- fileUrl(path: string): string;
674
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
675
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
676
- downloadFile(path: string): Promise<string>;
677
- };
678
- options: object;
679
- req: import("frogbot").FrogBotRequest;
680
- }) => Promise<import("frogbot").PieceOption[]>;
681
- protectContent: (args: {
682
- input: Partial<{
683
- disableNotification: boolean;
684
- protectContent: boolean;
685
- chatId: string | number;
686
- audio: string | {
687
- fileId: string | number;
688
- name?: string | undefined;
689
- };
690
- parseMode: "MarkdownV2" | "HTML" | "None";
691
- replyToMessageId?: number | undefined;
692
- replyMarkup?: Record<string, unknown> | undefined;
693
- messageThreadId?: number | undefined;
694
- caption?: string | undefined;
695
- duration?: number | undefined;
696
- performer?: string | undefined;
697
- title?: string | undefined;
698
- thumbnail?: string | undefined;
699
- }>;
700
- client: {
701
- fileUrl(path: string): string;
702
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
703
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
704
- downloadFile(path: string): Promise<string>;
705
- };
706
- options: object;
707
- req: import("frogbot").FrogBotRequest;
708
- }) => Promise<import("frogbot").PieceOption[]>;
709
- chatId: (args: {
710
- input: Partial<{
711
- disableNotification: boolean;
712
- protectContent: boolean;
713
- chatId: string | number;
714
- audio: string | {
715
- fileId: string | number;
716
- name?: string | undefined;
717
- };
718
- parseMode: "MarkdownV2" | "HTML" | "None";
719
- replyToMessageId?: number | undefined;
720
- replyMarkup?: Record<string, unknown> | undefined;
721
- messageThreadId?: number | undefined;
722
- caption?: string | undefined;
723
- duration?: number | undefined;
724
- performer?: string | undefined;
725
- title?: string | undefined;
726
- thumbnail?: string | undefined;
727
- }>;
728
- client: {
729
- fileUrl(path: string): string;
730
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
731
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
732
- downloadFile(path: string): Promise<string>;
733
- };
734
- options: object;
735
- req: import("frogbot").FrogBotRequest;
736
- }) => Promise<import("frogbot").PieceOption[]>;
737
- audio: (args: {
738
- input: Partial<{
739
- disableNotification: boolean;
740
- protectContent: boolean;
741
- chatId: string | number;
742
- audio: string | {
743
- fileId: string | number;
744
- name?: string | undefined;
745
- };
746
- parseMode: "MarkdownV2" | "HTML" | "None";
747
- replyToMessageId?: number | undefined;
748
- replyMarkup?: Record<string, unknown> | undefined;
749
- messageThreadId?: number | undefined;
750
- caption?: string | undefined;
751
- duration?: number | undefined;
752
- performer?: string | undefined;
753
- title?: string | undefined;
754
- thumbnail?: string | undefined;
755
- }>;
756
- client: {
757
- fileUrl(path: string): string;
758
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
759
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
760
- downloadFile(path: string): Promise<string>;
761
- };
762
- options: object;
763
- req: import("frogbot").FrogBotRequest;
764
- }) => Promise<import("frogbot").PieceOption[]>;
765
- parseMode: (args: {
766
- input: Partial<{
767
- disableNotification: boolean;
768
- protectContent: boolean;
769
- chatId: string | number;
770
- audio: string | {
771
- fileId: string | number;
772
- name?: string | undefined;
773
- };
774
- parseMode: "MarkdownV2" | "HTML" | "None";
775
- replyToMessageId?: number | undefined;
776
- replyMarkup?: Record<string, unknown> | undefined;
777
- messageThreadId?: number | undefined;
778
- caption?: string | undefined;
779
- duration?: number | undefined;
780
- performer?: string | undefined;
781
- title?: string | undefined;
782
- thumbnail?: string | undefined;
783
- }>;
784
- client: {
785
- fileUrl(path: string): string;
786
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
787
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
788
- downloadFile(path: string): Promise<string>;
789
- };
790
- options: object;
791
- req: import("frogbot").FrogBotRequest;
792
- }) => Promise<import("frogbot").PieceOption[]>;
793
- replyToMessageId?: ((args: {
794
- input: Partial<{
795
- disableNotification: boolean;
796
- protectContent: boolean;
797
- chatId: string | number;
798
- audio: string | {
799
- fileId: string | number;
800
- name?: string | undefined;
801
- };
802
- parseMode: "MarkdownV2" | "HTML" | "None";
803
- replyToMessageId?: number | undefined;
804
- replyMarkup?: Record<string, unknown> | undefined;
805
- messageThreadId?: number | undefined;
806
- caption?: string | undefined;
807
- duration?: number | undefined;
808
- performer?: string | undefined;
809
- title?: string | undefined;
810
- thumbnail?: string | undefined;
811
- }>;
812
- client: {
813
- fileUrl(path: string): string;
814
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
815
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
816
- downloadFile(path: string): Promise<string>;
817
- };
818
- options: object;
819
- req: import("frogbot").FrogBotRequest;
820
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
821
- replyMarkup?: ((args: {
822
- input: Partial<{
823
- disableNotification: boolean;
824
- protectContent: boolean;
825
- chatId: string | number;
826
- audio: string | {
827
- fileId: string | number;
828
- name?: string | undefined;
829
- };
830
- parseMode: "MarkdownV2" | "HTML" | "None";
831
- replyToMessageId?: number | undefined;
832
- replyMarkup?: Record<string, unknown> | undefined;
833
- messageThreadId?: number | undefined;
834
- caption?: string | undefined;
835
- duration?: number | undefined;
836
- performer?: string | undefined;
837
- title?: string | undefined;
838
- thumbnail?: string | undefined;
839
- }>;
840
- client: {
841
- fileUrl(path: string): string;
842
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
843
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
844
- downloadFile(path: string): Promise<string>;
845
- };
846
- options: object;
847
- req: import("frogbot").FrogBotRequest;
848
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
849
- messageThreadId?: ((args: {
850
- input: Partial<{
851
- disableNotification: boolean;
852
- protectContent: boolean;
853
- chatId: string | number;
854
- audio: string | {
855
- fileId: string | number;
856
- name?: string | undefined;
857
- };
858
- parseMode: "MarkdownV2" | "HTML" | "None";
859
- replyToMessageId?: number | undefined;
860
- replyMarkup?: Record<string, unknown> | undefined;
861
- messageThreadId?: number | undefined;
862
- caption?: string | undefined;
863
- duration?: number | undefined;
864
- performer?: string | undefined;
865
- title?: string | undefined;
866
- thumbnail?: string | undefined;
867
- }>;
868
- client: {
869
- fileUrl(path: string): string;
870
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
871
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
872
- downloadFile(path: string): Promise<string>;
873
- };
874
- options: object;
875
- req: import("frogbot").FrogBotRequest;
876
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
877
- caption?: ((args: {
878
- input: Partial<{
879
- disableNotification: boolean;
880
- protectContent: boolean;
881
- chatId: string | number;
882
- audio: string | {
883
- fileId: string | number;
884
- name?: string | undefined;
885
- };
886
- parseMode: "MarkdownV2" | "HTML" | "None";
887
- replyToMessageId?: number | undefined;
888
- replyMarkup?: Record<string, unknown> | undefined;
889
- messageThreadId?: number | undefined;
890
- caption?: string | undefined;
891
- duration?: number | undefined;
892
- performer?: string | undefined;
893
- title?: string | undefined;
894
- thumbnail?: string | undefined;
895
- }>;
896
- client: {
897
- fileUrl(path: string): string;
898
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
899
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
900
- downloadFile(path: string): Promise<string>;
901
- };
902
- options: object;
903
- req: import("frogbot").FrogBotRequest;
904
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
905
- duration?: ((args: {
906
- input: Partial<{
907
- disableNotification: boolean;
908
- protectContent: boolean;
909
- chatId: string | number;
910
- audio: string | {
911
- fileId: string | number;
912
- name?: string | undefined;
913
- };
914
- parseMode: "MarkdownV2" | "HTML" | "None";
915
- replyToMessageId?: number | undefined;
916
- replyMarkup?: Record<string, unknown> | undefined;
917
- messageThreadId?: number | undefined;
918
- caption?: string | undefined;
919
- duration?: number | undefined;
920
- performer?: string | undefined;
921
- title?: string | undefined;
922
- thumbnail?: string | undefined;
923
- }>;
924
- client: {
925
- fileUrl(path: string): string;
926
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
927
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
928
- downloadFile(path: string): Promise<string>;
929
- };
930
- options: object;
931
- req: import("frogbot").FrogBotRequest;
932
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
933
- performer?: ((args: {
934
- input: Partial<{
935
- disableNotification: boolean;
936
- protectContent: boolean;
937
- chatId: string | number;
938
- audio: string | {
939
- fileId: string | number;
940
- name?: string | undefined;
941
- };
942
- parseMode: "MarkdownV2" | "HTML" | "None";
943
- replyToMessageId?: number | undefined;
944
- replyMarkup?: Record<string, unknown> | undefined;
945
- messageThreadId?: number | undefined;
946
- caption?: string | undefined;
947
- duration?: number | undefined;
948
- performer?: string | undefined;
949
- title?: string | undefined;
950
- thumbnail?: string | undefined;
951
- }>;
952
- client: {
953
- fileUrl(path: string): string;
954
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
955
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
956
- downloadFile(path: string): Promise<string>;
957
- };
958
- options: object;
959
- req: import("frogbot").FrogBotRequest;
960
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
961
- title?: ((args: {
962
- input: Partial<{
963
- disableNotification: boolean;
964
- protectContent: boolean;
965
- chatId: string | number;
966
- audio: string | {
967
- fileId: string | number;
968
- name?: string | undefined;
969
- };
970
- parseMode: "MarkdownV2" | "HTML" | "None";
971
- replyToMessageId?: number | undefined;
972
- replyMarkup?: Record<string, unknown> | undefined;
973
- messageThreadId?: number | undefined;
974
- caption?: string | undefined;
975
- duration?: number | undefined;
976
- performer?: string | undefined;
977
- title?: string | undefined;
978
- thumbnail?: string | undefined;
979
- }>;
980
- client: {
981
- fileUrl(path: string): string;
982
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
983
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
984
- downloadFile(path: string): Promise<string>;
985
- };
986
- options: object;
987
- req: import("frogbot").FrogBotRequest;
988
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
989
- thumbnail?: ((args: {
990
- input: Partial<{
991
- disableNotification: boolean;
992
- protectContent: boolean;
993
- chatId: string | number;
994
- audio: string | {
995
- fileId: string | number;
996
- name?: string | undefined;
997
- };
998
- parseMode: "MarkdownV2" | "HTML" | "None";
999
- replyToMessageId?: number | undefined;
1000
- replyMarkup?: Record<string, unknown> | undefined;
1001
- messageThreadId?: number | undefined;
1002
- caption?: string | undefined;
1003
- duration?: number | undefined;
1004
- performer?: string | undefined;
1005
- title?: string | undefined;
1006
- thumbnail?: string | undefined;
1007
- }>;
1008
- client: {
1009
- fileUrl(path: string): string;
1010
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1011
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1012
- downloadFile(path: string): Promise<string>;
1013
- };
1014
- options: object;
1015
- req: import("frogbot").FrogBotRequest;
1016
- }) => Promise<import("frogbot").PieceOption[]>) | undefined;
1017
- }> | undefined;
111
+ fileUrl(path: string): string;
112
+ call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
113
+ request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
114
+ downloadFile(path: string): Promise<string>;
115
+ }, {
116
+ [x: string]: unknown;
117
+ ok: true;
118
+ result?: unknown;
119
+ }> & {
120
+ slug: "sendMedia";
121
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
122
+ replyToMessageId: z.ZodOptional<z.ZodNumber>;
123
+ replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
124
+ messageThreadId: z.ZodOptional<z.ZodNumber>;
125
+ disableNotification: z.ZodDefault<z.ZodBoolean>;
126
+ protectContent: z.ZodDefault<z.ZodBoolean>;
127
+ chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
128
+ document: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
129
+ fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
130
+ name: z.ZodOptional<z.ZodString>;
131
+ }, z.core.$strip>]>;
132
+ caption: z.ZodOptional<z.ZodString>;
133
+ parseMode: z.ZodDefault<z.ZodEnum<{
134
+ MarkdownV2: "MarkdownV2";
135
+ HTML: "HTML";
136
+ None: "None";
137
+ }>>;
138
+ }, z.core.$strip>, z.ZodObject<{
139
+ ok: z.ZodLiteral<true>;
140
+ result: z.ZodOptional<z.ZodUnknown>;
141
+ }, z.core.$loose>, {
142
+ webhookSecret?: string | undefined;
143
+ botUsername?: string | undefined;
144
+ allowedUserIds?: string[] | undefined;
145
+ }, {
146
+ fileUrl(path: string): string;
147
+ call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
148
+ request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
149
+ downloadFile(path: string): Promise<string>;
150
+ }, {
151
+ [x: string]: unknown;
152
+ ok: true;
153
+ result?: unknown;
154
+ }> & {
155
+ slug: "sendDocument";
156
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
157
+ replyToMessageId: z.ZodOptional<z.ZodNumber>;
158
+ replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
159
+ messageThreadId: z.ZodOptional<z.ZodNumber>;
160
+ disableNotification: z.ZodDefault<z.ZodBoolean>;
161
+ protectContent: z.ZodDefault<z.ZodBoolean>;
162
+ chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
163
+ audio: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
164
+ fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
165
+ name: z.ZodOptional<z.ZodString>;
166
+ }, z.core.$strip>]>;
167
+ caption: z.ZodOptional<z.ZodString>;
168
+ parseMode: z.ZodDefault<z.ZodEnum<{
169
+ MarkdownV2: "MarkdownV2";
170
+ HTML: "HTML";
171
+ None: "None";
172
+ }>>;
173
+ duration: z.ZodOptional<z.ZodNumber>;
174
+ performer: z.ZodOptional<z.ZodString>;
175
+ title: z.ZodOptional<z.ZodString>;
176
+ thumbnail: z.ZodOptional<z.ZodString>;
177
+ }, z.core.$strip>, z.ZodObject<{
178
+ ok: z.ZodLiteral<true>;
179
+ result: z.ZodOptional<z.ZodUnknown>;
180
+ }, z.core.$loose>, {
181
+ webhookSecret?: string | undefined;
182
+ botUsername?: string | undefined;
183
+ allowedUserIds?: string[] | undefined;
184
+ }, {
185
+ fileUrl(path: string): string;
186
+ call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
187
+ request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
188
+ downloadFile(path: string): Promise<string>;
189
+ }, {
190
+ [x: string]: unknown;
191
+ ok: true;
192
+ result?: unknown;
193
+ }> & {
194
+ slug: "sendAudio";
1018
195
  }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1019
196
  replyToMessageId: z.ZodOptional<z.ZodNumber>;
1020
197
  replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
@@ -1031,12 +208,22 @@ export declare const createTelegramBot: import("frogbot").PieceFactory<{
1031
208
  }, z.core.$strip>, z.ZodObject<{
1032
209
  ok: z.ZodLiteral<true>;
1033
210
  result: z.ZodOptional<z.ZodUnknown>;
1034
- }, z.core.$loose>, object, {
211
+ }, z.core.$loose>, {
212
+ webhookSecret?: string | undefined;
213
+ botUsername?: string | undefined;
214
+ allowedUserIds?: string[] | undefined;
215
+ }, {
1035
216
  fileUrl(path: string): string;
1036
217
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1037
218
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1038
219
  downloadFile(path: string): Promise<string>;
1039
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
220
+ }, {
221
+ [x: string]: unknown;
222
+ ok: true;
223
+ result?: unknown;
224
+ }> & {
225
+ slug: "sendLocation";
226
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1040
227
  messageThreadId: z.ZodOptional<z.ZodNumber>;
1041
228
  disableNotification: z.ZodDefault<z.ZodBoolean>;
1042
229
  protectContent: z.ZodDefault<z.ZodBoolean>;
@@ -1058,12 +245,22 @@ export declare const createTelegramBot: import("frogbot").PieceFactory<{
1058
245
  }, z.core.$strip>, z.ZodObject<{
1059
246
  ok: z.ZodLiteral<true>;
1060
247
  result: z.ZodOptional<z.ZodUnknown>;
1061
- }, z.core.$loose>, object, {
248
+ }, z.core.$loose>, {
249
+ webhookSecret?: string | undefined;
250
+ botUsername?: string | undefined;
251
+ allowedUserIds?: string[] | undefined;
252
+ }, {
1062
253
  fileUrl(path: string): string;
1063
254
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1064
255
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1065
256
  downloadFile(path: string): Promise<string>;
1066
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
257
+ }, {
258
+ [x: string]: unknown;
259
+ ok: true;
260
+ result?: unknown;
261
+ }> & {
262
+ slug: "sendMediaGroup";
263
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1067
264
  replyToMessageId: z.ZodOptional<z.ZodNumber>;
1068
265
  replyMarkup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
1069
266
  messageThreadId: z.ZodOptional<z.ZodNumber>;
@@ -1090,12 +287,22 @@ export declare const createTelegramBot: import("frogbot").PieceFactory<{
1090
287
  }, z.core.$strip>, z.ZodObject<{
1091
288
  ok: z.ZodLiteral<true>;
1092
289
  result: z.ZodOptional<z.ZodUnknown>;
1093
- }, z.core.$loose>, object, {
290
+ }, z.core.$loose>, {
291
+ webhookSecret?: string | undefined;
292
+ botUsername?: string | undefined;
293
+ allowedUserIds?: string[] | undefined;
294
+ }, {
1094
295
  fileUrl(path: string): string;
1095
296
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1096
297
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1097
298
  downloadFile(path: string): Promise<string>;
1098
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
299
+ }, {
300
+ [x: string]: unknown;
301
+ ok: true;
302
+ result?: unknown;
303
+ }> & {
304
+ slug: "sendPoll";
305
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1099
306
  chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
1100
307
  messageThreadId: z.ZodOptional<z.ZodNumber>;
1101
308
  action: z.ZodEnum<{
@@ -1114,12 +321,22 @@ export declare const createTelegramBot: import("frogbot").PieceFactory<{
1114
321
  }, z.core.$strip>, z.ZodObject<{
1115
322
  ok: z.ZodLiteral<true>;
1116
323
  result: z.ZodOptional<z.ZodUnknown>;
1117
- }, z.core.$loose>, object, {
324
+ }, z.core.$loose>, {
325
+ webhookSecret?: string | undefined;
326
+ botUsername?: string | undefined;
327
+ allowedUserIds?: string[] | undefined;
328
+ }, {
1118
329
  fileUrl(path: string): string;
1119
330
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1120
331
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1121
332
  downloadFile(path: string): Promise<string>;
1122
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
333
+ }, {
334
+ [x: string]: unknown;
335
+ ok: true;
336
+ result?: unknown;
337
+ }> & {
338
+ slug: "sendChatAction";
339
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1123
340
  chatId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
1124
341
  messageId: z.ZodOptional<z.ZodNumber>;
1125
342
  inlineMessageId: z.ZodOptional<z.ZodString>;
@@ -1133,23 +350,43 @@ export declare const createTelegramBot: import("frogbot").PieceFactory<{
1133
350
  }, z.core.$strip>, z.ZodObject<{
1134
351
  ok: z.ZodLiteral<true>;
1135
352
  result: z.ZodOptional<z.ZodUnknown>;
1136
- }, z.core.$loose>, object, {
353
+ }, z.core.$loose>, {
354
+ webhookSecret?: string | undefined;
355
+ botUsername?: string | undefined;
356
+ allowedUserIds?: string[] | undefined;
357
+ }, {
1137
358
  fileUrl(path: string): string;
1138
359
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1139
360
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1140
361
  downloadFile(path: string): Promise<string>;
1141
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
362
+ }, {
363
+ [x: string]: unknown;
364
+ ok: true;
365
+ result?: unknown;
366
+ }> & {
367
+ slug: "editMessageText";
368
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1142
369
  chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
1143
370
  messageId: z.ZodNumber;
1144
371
  }, z.core.$strip>, z.ZodObject<{
1145
372
  ok: z.ZodLiteral<true>;
1146
373
  result: z.ZodOptional<z.ZodUnknown>;
1147
- }, z.core.$loose>, object, {
374
+ }, z.core.$loose>, {
375
+ webhookSecret?: string | undefined;
376
+ botUsername?: string | undefined;
377
+ allowedUserIds?: string[] | undefined;
378
+ }, {
1148
379
  fileUrl(path: string): string;
1149
380
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1150
381
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1151
382
  downloadFile(path: string): Promise<string>;
1152
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
383
+ }, {
384
+ [x: string]: unknown;
385
+ ok: true;
386
+ result?: unknown;
387
+ }> & {
388
+ slug: "deleteMessage";
389
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1153
390
  messageThreadId: z.ZodOptional<z.ZodNumber>;
1154
391
  disableNotification: z.ZodDefault<z.ZodBoolean>;
1155
392
  protectContent: z.ZodDefault<z.ZodBoolean>;
@@ -1159,87 +396,138 @@ export declare const createTelegramBot: import("frogbot").PieceFactory<{
1159
396
  }, z.core.$strip>, z.ZodObject<{
1160
397
  ok: z.ZodLiteral<true>;
1161
398
  result: z.ZodOptional<z.ZodUnknown>;
1162
- }, z.core.$loose>, object, {
399
+ }, z.core.$loose>, {
400
+ webhookSecret?: string | undefined;
401
+ botUsername?: string | undefined;
402
+ allowedUserIds?: string[] | undefined;
403
+ }, {
1163
404
  fileUrl(path: string): string;
1164
405
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1165
406
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1166
407
  downloadFile(path: string): Promise<string>;
1167
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
408
+ }, {
409
+ [x: string]: unknown;
410
+ ok: true;
411
+ result?: unknown;
412
+ }> & {
413
+ slug: "forwardMessage";
414
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1168
415
  chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
1169
416
  messageId: z.ZodNumber;
1170
417
  disableNotification: z.ZodDefault<z.ZodBoolean>;
1171
418
  }, z.core.$strip>, z.ZodObject<{
1172
419
  ok: z.ZodLiteral<true>;
1173
420
  result: z.ZodOptional<z.ZodUnknown>;
1174
- }, z.core.$loose>, object, {
421
+ }, z.core.$loose>, {
422
+ webhookSecret?: string | undefined;
423
+ botUsername?: string | undefined;
424
+ allowedUserIds?: string[] | undefined;
425
+ }, {
1175
426
  fileUrl(path: string): string;
1176
427
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1177
428
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1178
429
  downloadFile(path: string): Promise<string>;
1179
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
430
+ }, {
431
+ [x: string]: unknown;
432
+ ok: true;
433
+ result?: unknown;
434
+ }> & {
435
+ slug: "pinMessage";
436
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1180
437
  chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
1181
438
  messageId: z.ZodOptional<z.ZodNumber>;
1182
439
  }, z.core.$strip>, z.ZodObject<{
1183
440
  ok: z.ZodLiteral<true>;
1184
441
  result: z.ZodOptional<z.ZodUnknown>;
1185
- }, z.core.$loose>, object, {
442
+ }, z.core.$loose>, {
443
+ webhookSecret?: string | undefined;
444
+ botUsername?: string | undefined;
445
+ allowedUserIds?: string[] | undefined;
446
+ }, {
1186
447
  fileUrl(path: string): string;
1187
448
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1188
449
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1189
450
  downloadFile(path: string): Promise<string>;
1190
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
451
+ }, {
452
+ [x: string]: unknown;
453
+ ok: true;
454
+ result?: unknown;
455
+ }> & {
456
+ slug: "unpinMessage";
457
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1191
458
  chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
1192
459
  }, z.core.$strip>, z.ZodObject<{
1193
460
  ok: z.ZodLiteral<true>;
1194
461
  result: z.ZodOptional<z.ZodUnknown>;
1195
- }, z.core.$loose>, object, {
462
+ }, z.core.$loose>, {
463
+ webhookSecret?: string | undefined;
464
+ botUsername?: string | undefined;
465
+ allowedUserIds?: string[] | undefined;
466
+ }, {
1196
467
  fileUrl(path: string): string;
1197
468
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1198
469
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1199
470
  downloadFile(path: string): Promise<string>;
1200
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
471
+ }, {
472
+ [x: string]: unknown;
473
+ ok: true;
474
+ result?: unknown;
475
+ }> & {
476
+ slug: "getChat";
477
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1201
478
  chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
1202
479
  userId: z.ZodNumber;
1203
480
  }, z.core.$strip>, z.ZodObject<{
1204
481
  ok: z.ZodLiteral<true>;
1205
482
  result: z.ZodOptional<z.ZodUnknown>;
1206
- }, z.core.$loose>, object, {
483
+ }, z.core.$loose>, {
484
+ webhookSecret?: string | undefined;
485
+ botUsername?: string | undefined;
486
+ allowedUserIds?: string[] | undefined;
487
+ }, {
1207
488
  fileUrl(path: string): string;
1208
489
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1209
490
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1210
491
  downloadFile(path: string): Promise<string>;
1211
- }>, {
1212
- slug: string;
1213
- description: string;
1214
- input: z.ZodObject<{
1215
- fileId: z.ZodString;
1216
- download: z.ZodDefault<z.ZodBoolean>;
1217
- }, z.core.$strip>;
1218
- output: z.ZodObject<{
1219
- fileInfo: z.ZodObject<{
1220
- file_id: z.ZodString;
1221
- file_unique_id: z.ZodString;
1222
- file_size: z.ZodOptional<z.ZodNumber>;
1223
- file_path: z.ZodOptional<z.ZodString>;
1224
- }, z.core.$loose>;
1225
- fileUrl: z.ZodOptional<z.ZodString>;
1226
- fileContentBase64: z.ZodOptional<z.ZodString>;
1227
- }, z.core.$strip>;
1228
- idempotent: boolean;
1229
- run({ client, input, }: import("frogbot").PieceRunArgs<{
1230
- fileId: string;
1231
- download: boolean;
1232
- }, object, TelegramBotClient>): Promise<{
1233
- fileInfo: {
1234
- [x: string]: unknown;
1235
- file_id: string;
1236
- file_unique_id: string;
1237
- file_size?: number | undefined;
1238
- file_path?: string | undefined;
1239
- };
1240
- fileUrl: string | undefined;
1241
- fileContentBase64: string | undefined;
1242
- }>;
492
+ }, {
493
+ [x: string]: unknown;
494
+ ok: true;
495
+ result?: unknown;
496
+ }> & {
497
+ slug: "getChatMember";
498
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
499
+ fileId: z.ZodString;
500
+ download: z.ZodDefault<z.ZodBoolean>;
501
+ }, z.core.$strip>, z.ZodObject<{
502
+ fileInfo: z.ZodObject<{
503
+ file_id: z.ZodString;
504
+ file_unique_id: z.ZodString;
505
+ file_size: z.ZodOptional<z.ZodNumber>;
506
+ file_path: z.ZodOptional<z.ZodString>;
507
+ }, z.core.$loose>;
508
+ fileUrl: z.ZodOptional<z.ZodString>;
509
+ fileContentBase64: z.ZodOptional<z.ZodString>;
510
+ }, z.core.$strip>, {
511
+ webhookSecret?: string | undefined;
512
+ botUsername?: string | undefined;
513
+ allowedUserIds?: string[] | undefined;
514
+ }, {
515
+ fileUrl(path: string): string;
516
+ call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
517
+ request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
518
+ downloadFile(path: string): Promise<string>;
519
+ }, {
520
+ fileInfo: {
521
+ [x: string]: unknown;
522
+ file_id: string;
523
+ file_unique_id: string;
524
+ file_size?: number | undefined;
525
+ file_path?: string | undefined;
526
+ };
527
+ fileUrl?: string | undefined;
528
+ fileContentBase64?: string | undefined;
529
+ }> & {
530
+ slug: "getFile";
1243
531
  }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1244
532
  chatId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
1245
533
  name: z.ZodOptional<z.ZodString>;
@@ -1249,12 +537,22 @@ export declare const createTelegramBot: import("frogbot").PieceFactory<{
1249
537
  }, z.core.$strip>, z.ZodObject<{
1250
538
  ok: z.ZodLiteral<true>;
1251
539
  result: z.ZodOptional<z.ZodUnknown>;
1252
- }, z.core.$loose>, object, {
540
+ }, z.core.$loose>, {
541
+ webhookSecret?: string | undefined;
542
+ botUsername?: string | undefined;
543
+ allowedUserIds?: string[] | undefined;
544
+ }, {
1253
545
  fileUrl(path: string): string;
1254
546
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1255
547
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1256
548
  downloadFile(path: string): Promise<string>;
1257
- }>, import("frogbot").PieceActionDefinition<z.ZodObject<{
549
+ }, {
550
+ [x: string]: unknown;
551
+ ok: true;
552
+ result?: unknown;
553
+ }> & {
554
+ slug: "createInviteLink";
555
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
1258
556
  callbackQueryId: z.ZodString;
1259
557
  text: z.ZodOptional<z.ZodString>;
1260
558
  showAlert: z.ZodDefault<z.ZodBoolean>;
@@ -1263,65 +561,92 @@ export declare const createTelegramBot: import("frogbot").PieceFactory<{
1263
561
  }, z.core.$strip>, z.ZodObject<{
1264
562
  ok: z.ZodLiteral<true>;
1265
563
  result: z.ZodOptional<z.ZodUnknown>;
1266
- }, z.core.$loose>, object, {
564
+ }, z.core.$loose>, {
565
+ webhookSecret?: string | undefined;
566
+ botUsername?: string | undefined;
567
+ allowedUserIds?: string[] | undefined;
568
+ }, {
1267
569
  fileUrl(path: string): string;
1268
570
  call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1269
571
  request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1270
572
  downloadFile(path: string): Promise<string>;
1271
- }>, {
573
+ }, {
574
+ [x: string]: unknown;
575
+ ok: true;
576
+ result?: unknown;
577
+ }> & {
578
+ slug: "answerCallbackQuery";
579
+ }, import("frogbot").PieceActionDefinition<z.ZodObject<{
580
+ method: z.ZodDefault<z.ZodEnum<{
581
+ POST: "POST";
582
+ GET: "GET";
583
+ PUT: "PUT";
584
+ PATCH: "PATCH";
585
+ DELETE: "DELETE";
586
+ }>>;
587
+ endpoint: z.ZodString;
588
+ headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
589
+ query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
590
+ body: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
591
+ }, z.core.$strip>, z.ZodUnknown, {
592
+ webhookSecret?: string | undefined;
593
+ botUsername?: string | undefined;
594
+ allowedUserIds?: string[] | undefined;
595
+ }, {
596
+ fileUrl(path: string): string;
597
+ call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
598
+ request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
599
+ downloadFile(path: string): Promise<string>;
600
+ }, unknown> & {
601
+ slug: "customApiCall";
602
+ }];
603
+ readonly triggers: readonly [{
1272
604
  slug: string;
605
+ label?: string;
1273
606
  description: string;
1274
607
  input: z.ZodObject<{
1275
- method: z.ZodDefault<z.ZodEnum<{
1276
- POST: "POST";
1277
- GET: "GET";
1278
- PUT: "PUT";
1279
- PATCH: "PATCH";
1280
- DELETE: "DELETE";
1281
- }>>;
1282
- endpoint: z.ZodString;
1283
- headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
1284
- query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
1285
- body: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
608
+ updateTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
609
+ message: "message";
610
+ edited_message: "edited_message";
611
+ channel_post: "channel_post";
612
+ edited_channel_post: "edited_channel_post";
613
+ poll: "poll";
614
+ callback_query: "callback_query";
615
+ inline_query: "inline_query";
616
+ chosen_inline_result: "chosen_inline_result";
617
+ poll_answer: "poll_answer";
618
+ my_chat_member: "my_chat_member";
619
+ chat_member: "chat_member";
620
+ chat_join_request: "chat_join_request";
621
+ }>>>;
1286
622
  }, z.core.$strip>;
1287
- output: z.ZodUnknown;
1288
- idempotent: boolean;
1289
- run({ client, input, }: import("frogbot").PieceRunArgs<z.output<z.ZodObject<{
1290
- method: z.ZodDefault<z.ZodEnum<{
1291
- POST: "POST";
1292
- GET: "GET";
1293
- PUT: "PUT";
1294
- PATCH: "PATCH";
1295
- DELETE: "DELETE";
1296
- }>>;
1297
- endpoint: z.ZodString;
1298
- headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
1299
- query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
1300
- body: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
1301
- }, z.core.$strip>>, object, TelegramBotClient>): Promise<unknown>;
623
+ output?: z.ZodObject<{
624
+ update_id: z.ZodOptional<z.ZodNumber>;
625
+ }, z.core.$catchall<z.ZodType<import("frogbot").PieceJSON, unknown, z.core.$ZodTypeInternals<import("frogbot").PieceJSON, unknown>>>> | undefined;
626
+ sample?: {
627
+ [x: string]: import("frogbot").PieceJSON;
628
+ update_id?: number | undefined;
629
+ } | undefined;
630
+ } & {
631
+ type: "app";
632
+ event: string;
633
+ run(args: import("frogbot").PieceRunArgs<{
634
+ updateTypes: ("message" | "edited_message" | "channel_post" | "edited_channel_post" | "poll" | "callback_query" | "inline_query" | "chosen_inline_result" | "poll_answer" | "my_chat_member" | "chat_member" | "chat_join_request")[];
635
+ }, {
636
+ webhookSecret?: string | undefined;
637
+ botUsername?: string | undefined;
638
+ allowedUserIds?: string[] | undefined;
639
+ }, {
640
+ fileUrl(path: string): string;
641
+ call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
642
+ request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
643
+ downloadFile(path: string): Promise<string>;
644
+ }>): Promise<import("frogbot").TriggerEvent<{
645
+ [x: string]: import("frogbot").PieceJSON;
646
+ update_id?: number | undefined;
647
+ }>[]>;
648
+ } & {
649
+ slug: "newUpdate";
1302
650
  }];
1303
- readonly triggers: readonly [import("frogbot").PieceAppTrigger<z.ZodObject<{
1304
- updateTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
1305
- message: "message";
1306
- edited_message: "edited_message";
1307
- channel_post: "channel_post";
1308
- edited_channel_post: "edited_channel_post";
1309
- poll: "poll";
1310
- callback_query: "callback_query";
1311
- inline_query: "inline_query";
1312
- chosen_inline_result: "chosen_inline_result";
1313
- poll_answer: "poll_answer";
1314
- my_chat_member: "my_chat_member";
1315
- chat_member: "chat_member";
1316
- chat_join_request: "chat_join_request";
1317
- }>>>;
1318
- }, z.core.$strip>, z.ZodObject<{
1319
- update_id: z.ZodOptional<z.ZodNumber>;
1320
- }, z.core.$catchall<z.ZodType<import("frogbot").PieceJSON, unknown, z.core.$ZodTypeInternals<import("frogbot").PieceJSON, unknown>>>>, object, {
1321
- fileUrl(path: string): string;
1322
- call(method: string, body?: unknown): Promise<import("./client.js").TelegramResponse>;
1323
- request(endpoint: string, request: import("./client.js").TelegramRequest): Promise<unknown>;
1324
- downloadFile(path: string): Promise<string>;
1325
- }>];
1326
651
  }>;
1327
652
  //# sourceMappingURL=index.d.ts.map