@frogbotai/piece-slack 0.27.0 → 0.29.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 (18) hide show
  1. package/dist/actions.d.ts +355 -114
  2. package/dist/actions.d.ts.map +1 -1
  3. package/dist/actions.js +25 -27
  4. package/dist/actions.js.map +1 -1
  5. package/dist/config.d.ts +1 -0
  6. package/dist/config.d.ts.map +1 -1
  7. package/dist/config.js.map +1 -1
  8. package/dist/define.d.ts +148 -0
  9. package/dist/define.d.ts.map +1 -0
  10. package/dist/define.js +3 -0
  11. package/dist/define.js.map +1 -0
  12. package/dist/index.d.ts +873 -139
  13. package/dist/index.d.ts.map +1 -1
  14. package/dist/triggers.d.ts +1349 -590
  15. package/dist/triggers.d.ts.map +1 -1
  16. package/dist/triggers.js +14 -16
  17. package/dist/triggers.js.map +1 -1
  18. package/package.json +3 -3
package/dist/triggers.d.ts CHANGED
@@ -1,592 +1,1351 @@
1
- import type { PieceAppTrigger } from 'frogbot/pieces';
2
1
  import { z } from 'zod';
3
- export declare const messageCreated: PieceAppTrigger<z.ZodObject<{
4
- ignoreBots: z.ZodDefault<z.ZodBoolean>;
5
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
6
- signingSecret?: string;
7
- }, {
8
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
9
- [x: string]: unknown;
10
- ok: true;
11
- }>;
12
- raw: ({ path, method, body, headers, token: tokenKind, }: {
13
- path: string;
14
- method?: string;
15
- body?: BodyInit | Record<string, unknown>;
16
- headers?: HeadersInit;
17
- token?: import("./client.js").SlackToken;
18
- }) => Promise<{
19
- status: number;
20
- headers: {
21
- [k: string]: string;
22
- };
23
- body: any;
24
- }>;
25
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
26
- path: string;
27
- body?: Record<string, unknown>;
28
- item: string;
29
- token?: import("./client.js").SlackToken;
30
- limit?: number;
31
- }) => Promise<Record<string, unknown>[]>;
32
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
33
- workspaceId: () => Promise<string>;
34
- }>;
35
- export declare const channelMessageCreated: PieceAppTrigger<z.ZodObject<{
36
- ignoreBots: z.ZodDefault<z.ZodBoolean>;
37
- channel: z.ZodString;
38
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
39
- signingSecret?: string;
40
- }, {
41
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
42
- [x: string]: unknown;
43
- ok: true;
44
- }>;
45
- raw: ({ path, method, body, headers, token: tokenKind, }: {
46
- path: string;
47
- method?: string;
48
- body?: BodyInit | Record<string, unknown>;
49
- headers?: HeadersInit;
50
- token?: import("./client.js").SlackToken;
51
- }) => Promise<{
52
- status: number;
53
- headers: {
54
- [k: string]: string;
55
- };
56
- body: any;
57
- }>;
58
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
59
- path: string;
60
- body?: Record<string, unknown>;
61
- item: string;
62
- token?: import("./client.js").SlackToken;
63
- limit?: number;
64
- }) => Promise<Record<string, unknown>[]>;
65
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
66
- workspaceId: () => Promise<string>;
67
- }>;
68
- export declare const directMessageCreated: PieceAppTrigger<z.ZodObject<{
69
- ignoreSelfMessages: z.ZodDefault<z.ZodBoolean>;
70
- ignoreBots: z.ZodDefault<z.ZodBoolean>;
71
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
72
- signingSecret?: string;
73
- }, {
74
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
75
- [x: string]: unknown;
76
- ok: true;
77
- }>;
78
- raw: ({ path, method, body, headers, token: tokenKind, }: {
79
- path: string;
80
- method?: string;
81
- body?: BodyInit | Record<string, unknown>;
82
- headers?: HeadersInit;
83
- token?: import("./client.js").SlackToken;
84
- }) => Promise<{
85
- status: number;
86
- headers: {
87
- [k: string]: string;
88
- };
89
- body: any;
90
- }>;
91
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
92
- path: string;
93
- body?: Record<string, unknown>;
94
- item: string;
95
- token?: import("./client.js").SlackToken;
96
- limit?: number;
97
- }) => Promise<Record<string, unknown>[]>;
98
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
99
- workspaceId: () => Promise<string>;
100
- }>;
101
- export declare const channelMentionCreated: PieceAppTrigger<z.ZodObject<{
102
- users: z.ZodDefault<z.ZodArray<z.ZodString>>;
103
- userGroups: z.ZodDefault<z.ZodArray<z.ZodString>>;
104
- channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
105
- ignoreBots: z.ZodDefault<z.ZodBoolean>;
106
- removeMention: z.ZodDefault<z.ZodBoolean>;
107
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
108
- signingSecret?: string;
109
- }, {
110
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
111
- [x: string]: unknown;
112
- ok: true;
113
- }>;
114
- raw: ({ path, method, body, headers, token: tokenKind, }: {
115
- path: string;
116
- method?: string;
117
- body?: BodyInit | Record<string, unknown>;
118
- headers?: HeadersInit;
119
- token?: import("./client.js").SlackToken;
120
- }) => Promise<{
121
- status: number;
122
- headers: {
123
- [k: string]: string;
124
- };
125
- body: any;
126
- }>;
127
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
128
- path: string;
129
- body?: Record<string, unknown>;
130
- item: string;
131
- token?: import("./client.js").SlackToken;
132
- limit?: number;
133
- }) => Promise<Record<string, unknown>[]>;
134
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
135
- workspaceId: () => Promise<string>;
136
- }>;
137
- export declare const reactionAdded: PieceAppTrigger<z.ZodObject<{
138
- emojis: z.ZodDefault<z.ZodArray<z.ZodString>>;
139
- user: z.ZodOptional<z.ZodString>;
140
- channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
141
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
142
- signingSecret?: string;
143
- }, {
144
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
145
- [x: string]: unknown;
146
- ok: true;
147
- }>;
148
- raw: ({ path, method, body, headers, token: tokenKind, }: {
149
- path: string;
150
- method?: string;
151
- body?: BodyInit | Record<string, unknown>;
152
- headers?: HeadersInit;
153
- token?: import("./client.js").SlackToken;
154
- }) => Promise<{
155
- status: number;
156
- headers: {
157
- [k: string]: string;
158
- };
159
- body: any;
160
- }>;
161
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
162
- path: string;
163
- body?: Record<string, unknown>;
164
- item: string;
165
- token?: import("./client.js").SlackToken;
166
- limit?: number;
167
- }) => Promise<Record<string, unknown>[]>;
168
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
169
- workspaceId: () => Promise<string>;
170
- }>;
171
- export declare const reactionRemoved: PieceAppTrigger<z.ZodObject<{
172
- emojis: z.ZodDefault<z.ZodArray<z.ZodString>>;
173
- user: z.ZodOptional<z.ZodString>;
174
- channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
175
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
176
- signingSecret?: string;
177
- }, {
178
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
179
- [x: string]: unknown;
180
- ok: true;
181
- }>;
182
- raw: ({ path, method, body, headers, token: tokenKind, }: {
183
- path: string;
184
- method?: string;
185
- body?: BodyInit | Record<string, unknown>;
186
- headers?: HeadersInit;
187
- token?: import("./client.js").SlackToken;
188
- }) => Promise<{
189
- status: number;
190
- headers: {
191
- [k: string]: string;
192
- };
193
- body: any;
194
- }>;
195
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
196
- path: string;
197
- body?: Record<string, unknown>;
198
- item: string;
199
- token?: import("./client.js").SlackToken;
200
- limit?: number;
201
- }) => Promise<Record<string, unknown>[]>;
202
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
203
- workspaceId: () => Promise<string>;
204
- }>;
205
- export declare const channelCreated: PieceAppTrigger<z.ZodObject<{}, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
206
- signingSecret?: string;
207
- }, {
208
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
209
- [x: string]: unknown;
210
- ok: true;
211
- }>;
212
- raw: ({ path, method, body, headers, token: tokenKind, }: {
213
- path: string;
214
- method?: string;
215
- body?: BodyInit | Record<string, unknown>;
216
- headers?: HeadersInit;
217
- token?: import("./client.js").SlackToken;
218
- }) => Promise<{
219
- status: number;
220
- headers: {
221
- [k: string]: string;
222
- };
223
- body: any;
224
- }>;
225
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
226
- path: string;
227
- body?: Record<string, unknown>;
228
- item: string;
229
- token?: import("./client.js").SlackToken;
230
- limit?: number;
231
- }) => Promise<Record<string, unknown>[]>;
232
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
233
- workspaceId: () => Promise<string>;
234
- }>;
235
- export declare const channelCommandCreated: PieceAppTrigger<z.ZodObject<{
236
- user: z.ZodString;
237
- commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
238
- channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
239
- ignoreBots: z.ZodDefault<z.ZodBoolean>;
240
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
241
- signingSecret?: string;
242
- }, {
243
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
244
- [x: string]: unknown;
245
- ok: true;
246
- }>;
247
- raw: ({ path, method, body, headers, token: tokenKind, }: {
248
- path: string;
249
- method?: string;
250
- body?: BodyInit | Record<string, unknown>;
251
- headers?: HeadersInit;
252
- token?: import("./client.js").SlackToken;
253
- }) => Promise<{
254
- status: number;
255
- headers: {
256
- [k: string]: string;
257
- };
258
- body: any;
259
- }>;
260
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
261
- path: string;
262
- body?: Record<string, unknown>;
263
- item: string;
264
- token?: import("./client.js").SlackToken;
265
- limit?: number;
266
- }) => Promise<Record<string, unknown>[]>;
267
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
268
- workspaceId: () => Promise<string>;
269
- }>;
270
- export declare const directMentionCreated: PieceAppTrigger<z.ZodObject<{
271
- ignoreSelfMessages: z.ZodDefault<z.ZodBoolean>;
272
- ignoreBots: z.ZodDefault<z.ZodBoolean>;
273
- user: z.ZodString;
274
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
275
- signingSecret?: string;
276
- }, {
277
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
278
- [x: string]: unknown;
279
- ok: true;
280
- }>;
281
- raw: ({ path, method, body, headers, token: tokenKind, }: {
282
- path: string;
283
- method?: string;
284
- body?: BodyInit | Record<string, unknown>;
285
- headers?: HeadersInit;
286
- token?: import("./client.js").SlackToken;
287
- }) => Promise<{
288
- status: number;
289
- headers: {
290
- [k: string]: string;
291
- };
292
- body: any;
293
- }>;
294
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
295
- path: string;
296
- body?: Record<string, unknown>;
297
- item: string;
298
- token?: import("./client.js").SlackToken;
299
- limit?: number;
300
- }) => Promise<Record<string, unknown>[]>;
301
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
302
- workspaceId: () => Promise<string>;
303
- }>;
304
- export declare const directCommandCreated: PieceAppTrigger<z.ZodObject<{
305
- user: z.ZodString;
306
- ignoreBots: z.ZodDefault<z.ZodBoolean>;
307
- commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
308
- ignoreSelfMessages: z.ZodDefault<z.ZodBoolean>;
309
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
310
- signingSecret?: string;
311
- }, {
312
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
313
- [x: string]: unknown;
314
- ok: true;
315
- }>;
316
- raw: ({ path, method, body, headers, token: tokenKind, }: {
317
- path: string;
318
- method?: string;
319
- body?: BodyInit | Record<string, unknown>;
320
- headers?: HeadersInit;
321
- token?: import("./client.js").SlackToken;
322
- }) => Promise<{
323
- status: number;
324
- headers: {
325
- [k: string]: string;
326
- };
327
- body: any;
328
- }>;
329
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
330
- path: string;
331
- body?: Record<string, unknown>;
332
- item: string;
333
- token?: import("./client.js").SlackToken;
334
- limit?: number;
335
- }) => Promise<Record<string, unknown>[]>;
336
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
337
- workspaceId: () => Promise<string>;
338
- }>;
339
- export declare const userJoined: PieceAppTrigger<z.ZodObject<{}, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
340
- signingSecret?: string;
341
- }, {
342
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
343
- [x: string]: unknown;
344
- ok: true;
345
- }>;
346
- raw: ({ path, method, body, headers, token: tokenKind, }: {
347
- path: string;
348
- method?: string;
349
- body?: BodyInit | Record<string, unknown>;
350
- headers?: HeadersInit;
351
- token?: import("./client.js").SlackToken;
352
- }) => Promise<{
353
- status: number;
354
- headers: {
355
- [k: string]: string;
356
- };
357
- body: any;
358
- }>;
359
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
360
- path: string;
361
- body?: Record<string, unknown>;
362
- item: string;
363
- token?: import("./client.js").SlackToken;
364
- limit?: number;
365
- }) => Promise<Record<string, unknown>[]>;
366
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
367
- workspaceId: () => Promise<string>;
368
- }>;
369
- export declare const messageSaved: PieceAppTrigger<z.ZodObject<{}, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
370
- signingSecret?: string;
371
- }, {
372
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
373
- [x: string]: unknown;
374
- ok: true;
375
- }>;
376
- raw: ({ path, method, body, headers, token: tokenKind, }: {
377
- path: string;
378
- method?: string;
379
- body?: BodyInit | Record<string, unknown>;
380
- headers?: HeadersInit;
381
- token?: import("./client.js").SlackToken;
382
- }) => Promise<{
383
- status: number;
384
- headers: {
385
- [k: string]: string;
386
- };
387
- body: any;
388
- }>;
389
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
390
- path: string;
391
- body?: Record<string, unknown>;
392
- item: string;
393
- token?: import("./client.js").SlackToken;
394
- limit?: number;
395
- }) => Promise<Record<string, unknown>[]>;
396
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
397
- workspaceId: () => Promise<string>;
398
- }>;
399
- export declare const customEmojiAdded: PieceAppTrigger<z.ZodObject<{}, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
400
- signingSecret?: string;
401
- }, {
402
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
403
- [x: string]: unknown;
404
- ok: true;
405
- }>;
406
- raw: ({ path, method, body, headers, token: tokenKind, }: {
407
- path: string;
408
- method?: string;
409
- body?: BodyInit | Record<string, unknown>;
410
- headers?: HeadersInit;
411
- token?: import("./client.js").SlackToken;
412
- }) => Promise<{
413
- status: number;
414
- headers: {
415
- [k: string]: string;
416
- };
417
- body: any;
418
- }>;
419
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
420
- path: string;
421
- body?: Record<string, unknown>;
422
- item: string;
423
- token?: import("./client.js").SlackToken;
424
- limit?: number;
425
- }) => Promise<Record<string, unknown>[]>;
426
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
427
- workspaceId: () => Promise<string>;
428
- }>;
429
- export declare const modalInteraction: PieceAppTrigger<z.ZodObject<{
430
- interactionType: z.ZodDefault<z.ZodEnum<{
431
- view_submission: "view_submission";
432
- view_closed: "view_closed";
433
- }>>;
434
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
435
- signingSecret?: string;
436
- }, {
437
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
438
- [x: string]: unknown;
439
- ok: true;
440
- }>;
441
- raw: ({ path, method, body, headers, token: tokenKind, }: {
442
- path: string;
443
- method?: string;
444
- body?: BodyInit | Record<string, unknown>;
445
- headers?: HeadersInit;
446
- token?: import("./client.js").SlackToken;
447
- }) => Promise<{
448
- status: number;
449
- headers: {
450
- [k: string]: string;
451
- };
452
- body: any;
453
- }>;
454
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
455
- path: string;
456
- body?: Record<string, unknown>;
457
- item: string;
458
- token?: import("./client.js").SlackToken;
459
- limit?: number;
460
- }) => Promise<Record<string, unknown>[]>;
461
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
462
- workspaceId: () => Promise<string>;
463
- }>;
464
- export declare const slackTriggers: (PieceAppTrigger<z.ZodObject<{
465
- ignoreBots: z.ZodDefault<z.ZodBoolean>;
466
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
467
- signingSecret?: string;
468
- }, {
469
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
470
- [x: string]: unknown;
471
- ok: true;
472
- }>;
473
- raw: ({ path, method, body, headers, token: tokenKind, }: {
474
- path: string;
475
- method?: string;
476
- body?: BodyInit | Record<string, unknown>;
477
- headers?: HeadersInit;
478
- token?: import("./client.js").SlackToken;
479
- }) => Promise<{
480
- status: number;
481
- headers: {
482
- [k: string]: string;
483
- };
484
- body: any;
485
- }>;
486
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
487
- path: string;
488
- body?: Record<string, unknown>;
489
- item: string;
490
- token?: import("./client.js").SlackToken;
491
- limit?: number;
492
- }) => Promise<Record<string, unknown>[]>;
493
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
494
- workspaceId: () => Promise<string>;
495
- }> | PieceAppTrigger<z.ZodObject<{
496
- emojis: z.ZodDefault<z.ZodArray<z.ZodString>>;
497
- user: z.ZodOptional<z.ZodString>;
498
- channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
499
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
500
- signingSecret?: string;
501
- }, {
502
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
503
- [x: string]: unknown;
504
- ok: true;
505
- }>;
506
- raw: ({ path, method, body, headers, token: tokenKind, }: {
507
- path: string;
508
- method?: string;
509
- body?: BodyInit | Record<string, unknown>;
510
- headers?: HeadersInit;
511
- token?: import("./client.js").SlackToken;
512
- }) => Promise<{
513
- status: number;
514
- headers: {
515
- [k: string]: string;
516
- };
517
- body: any;
518
- }>;
519
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
520
- path: string;
521
- body?: Record<string, unknown>;
522
- item: string;
523
- token?: import("./client.js").SlackToken;
524
- limit?: number;
525
- }) => Promise<Record<string, unknown>[]>;
526
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
527
- workspaceId: () => Promise<string>;
528
- }> | PieceAppTrigger<z.ZodObject<{}, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
529
- signingSecret?: string;
530
- }, {
531
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
532
- [x: string]: unknown;
533
- ok: true;
534
- }>;
535
- raw: ({ path, method, body, headers, token: tokenKind, }: {
536
- path: string;
537
- method?: string;
538
- body?: BodyInit | Record<string, unknown>;
539
- headers?: HeadersInit;
540
- token?: import("./client.js").SlackToken;
541
- }) => Promise<{
542
- status: number;
543
- headers: {
544
- [k: string]: string;
545
- };
546
- body: any;
547
- }>;
548
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
549
- path: string;
550
- body?: Record<string, unknown>;
551
- item: string;
552
- token?: import("./client.js").SlackToken;
553
- limit?: number;
554
- }) => Promise<Record<string, unknown>[]>;
555
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
556
- workspaceId: () => Promise<string>;
557
- }> | PieceAppTrigger<z.ZodObject<{
558
- interactionType: z.ZodDefault<z.ZodEnum<{
559
- view_submission: "view_submission";
560
- view_closed: "view_closed";
561
- }>>;
562
- }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
563
- signingSecret?: string;
564
- }, {
565
- request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
566
- [x: string]: unknown;
567
- ok: true;
568
- }>;
569
- raw: ({ path, method, body, headers, token: tokenKind, }: {
570
- path: string;
571
- method?: string;
572
- body?: BodyInit | Record<string, unknown>;
573
- headers?: HeadersInit;
574
- token?: import("./client.js").SlackToken;
575
- }) => Promise<{
576
- status: number;
577
- headers: {
578
- [k: string]: string;
579
- };
580
- body: any;
581
- }>;
582
- paginate: ({ path, body, item, token: tokenKind, limit, }: {
583
- path: string;
584
- body?: Record<string, unknown>;
585
- item: string;
586
- token?: import("./client.js").SlackToken;
587
- limit?: number;
588
- }) => Promise<Record<string, unknown>[]>;
589
- token: (kind?: import("./client.js").SlackToken) => string | undefined;
590
- workspaceId: () => Promise<string>;
591
- }>)[];
2
+ export declare const messageCreated: {
3
+ slug: string;
4
+ label?: string;
5
+ description: string;
6
+ input: z.ZodObject<{
7
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
8
+ }, z.core.$strip>;
9
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
10
+ sample?: Record<string, unknown> | undefined;
11
+ } & {
12
+ type: "app";
13
+ event: string;
14
+ run(args: import("frogbot").PieceRunArgs<{
15
+ ignoreBots: boolean;
16
+ }, {
17
+ signingSecret?: string | undefined;
18
+ }, {
19
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
20
+ [x: string]: unknown;
21
+ ok: true;
22
+ }>;
23
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
24
+ path: string;
25
+ method?: string;
26
+ body?: BodyInit | Record<string, unknown>;
27
+ headers?: HeadersInit;
28
+ token?: import("./client.js").SlackToken;
29
+ }) => Promise<{
30
+ status: number;
31
+ headers: {
32
+ [k: string]: string;
33
+ };
34
+ body: any;
35
+ }>;
36
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
37
+ path: string;
38
+ body?: Record<string, unknown>;
39
+ item: string;
40
+ token?: import("./client.js").SlackToken;
41
+ limit?: number;
42
+ }) => Promise<Record<string, unknown>[]>;
43
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
44
+ workspaceId: () => Promise<string>;
45
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
46
+ } & {
47
+ slug: "messageCreated";
48
+ };
49
+ export declare const channelMessageCreated: {
50
+ slug: string;
51
+ label?: string;
52
+ description: string;
53
+ input: z.ZodObject<{
54
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
55
+ channel: z.ZodString;
56
+ }, z.core.$strip>;
57
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
58
+ sample?: Record<string, unknown> | undefined;
59
+ } & {
60
+ type: "app";
61
+ event: string;
62
+ run(args: import("frogbot").PieceRunArgs<{
63
+ ignoreBots: boolean;
64
+ channel: string;
65
+ }, {
66
+ signingSecret?: string | undefined;
67
+ }, {
68
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
69
+ [x: string]: unknown;
70
+ ok: true;
71
+ }>;
72
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
73
+ path: string;
74
+ method?: string;
75
+ body?: BodyInit | Record<string, unknown>;
76
+ headers?: HeadersInit;
77
+ token?: import("./client.js").SlackToken;
78
+ }) => Promise<{
79
+ status: number;
80
+ headers: {
81
+ [k: string]: string;
82
+ };
83
+ body: any;
84
+ }>;
85
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
86
+ path: string;
87
+ body?: Record<string, unknown>;
88
+ item: string;
89
+ token?: import("./client.js").SlackToken;
90
+ limit?: number;
91
+ }) => Promise<Record<string, unknown>[]>;
92
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
93
+ workspaceId: () => Promise<string>;
94
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
95
+ } & {
96
+ slug: "channelMessageCreated";
97
+ };
98
+ export declare const directMessageCreated: {
99
+ slug: string;
100
+ label?: string;
101
+ description: string;
102
+ input: z.ZodObject<{
103
+ ignoreSelfMessages: z.ZodDefault<z.ZodBoolean>;
104
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
105
+ }, z.core.$strip>;
106
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
107
+ sample?: Record<string, unknown> | undefined;
108
+ } & {
109
+ type: "app";
110
+ event: string;
111
+ run(args: import("frogbot").PieceRunArgs<{
112
+ ignoreSelfMessages: boolean;
113
+ ignoreBots: boolean;
114
+ }, {
115
+ signingSecret?: string | undefined;
116
+ }, {
117
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
118
+ [x: string]: unknown;
119
+ ok: true;
120
+ }>;
121
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
122
+ path: string;
123
+ method?: string;
124
+ body?: BodyInit | Record<string, unknown>;
125
+ headers?: HeadersInit;
126
+ token?: import("./client.js").SlackToken;
127
+ }) => Promise<{
128
+ status: number;
129
+ headers: {
130
+ [k: string]: string;
131
+ };
132
+ body: any;
133
+ }>;
134
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
135
+ path: string;
136
+ body?: Record<string, unknown>;
137
+ item: string;
138
+ token?: import("./client.js").SlackToken;
139
+ limit?: number;
140
+ }) => Promise<Record<string, unknown>[]>;
141
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
142
+ workspaceId: () => Promise<string>;
143
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
144
+ } & {
145
+ slug: "directMessageCreated";
146
+ };
147
+ export declare const channelMentionCreated: {
148
+ slug: string;
149
+ label?: string;
150
+ description: string;
151
+ input: z.ZodObject<{
152
+ users: z.ZodDefault<z.ZodArray<z.ZodString>>;
153
+ userGroups: z.ZodDefault<z.ZodArray<z.ZodString>>;
154
+ channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
155
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
156
+ removeMention: z.ZodDefault<z.ZodBoolean>;
157
+ }, z.core.$strip>;
158
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
159
+ sample?: Record<string, unknown> | undefined;
160
+ } & {
161
+ type: "app";
162
+ event: string;
163
+ run(args: import("frogbot").PieceRunArgs<{
164
+ users: string[];
165
+ userGroups: string[];
166
+ channels: string[];
167
+ ignoreBots: boolean;
168
+ removeMention: boolean;
169
+ }, {
170
+ signingSecret?: string | undefined;
171
+ }, {
172
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
173
+ [x: string]: unknown;
174
+ ok: true;
175
+ }>;
176
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
177
+ path: string;
178
+ method?: string;
179
+ body?: BodyInit | Record<string, unknown>;
180
+ headers?: HeadersInit;
181
+ token?: import("./client.js").SlackToken;
182
+ }) => Promise<{
183
+ status: number;
184
+ headers: {
185
+ [k: string]: string;
186
+ };
187
+ body: any;
188
+ }>;
189
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
190
+ path: string;
191
+ body?: Record<string, unknown>;
192
+ item: string;
193
+ token?: import("./client.js").SlackToken;
194
+ limit?: number;
195
+ }) => Promise<Record<string, unknown>[]>;
196
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
197
+ workspaceId: () => Promise<string>;
198
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
199
+ } & {
200
+ slug: "channelMentionCreated";
201
+ };
202
+ export declare const reactionAdded: {
203
+ slug: string;
204
+ label?: string;
205
+ description: string;
206
+ input: z.ZodObject<{
207
+ emojis: z.ZodDefault<z.ZodArray<z.ZodString>>;
208
+ user: z.ZodOptional<z.ZodString>;
209
+ channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
210
+ }, z.core.$strip>;
211
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
212
+ sample?: Record<string, unknown> | undefined;
213
+ } & {
214
+ type: "app";
215
+ event: string;
216
+ run(args: import("frogbot").PieceRunArgs<{
217
+ emojis: string[];
218
+ channels: string[];
219
+ user?: string | undefined;
220
+ }, {
221
+ signingSecret?: string | undefined;
222
+ }, {
223
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
224
+ [x: string]: unknown;
225
+ ok: true;
226
+ }>;
227
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
228
+ path: string;
229
+ method?: string;
230
+ body?: BodyInit | Record<string, unknown>;
231
+ headers?: HeadersInit;
232
+ token?: import("./client.js").SlackToken;
233
+ }) => Promise<{
234
+ status: number;
235
+ headers: {
236
+ [k: string]: string;
237
+ };
238
+ body: any;
239
+ }>;
240
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
241
+ path: string;
242
+ body?: Record<string, unknown>;
243
+ item: string;
244
+ token?: import("./client.js").SlackToken;
245
+ limit?: number;
246
+ }) => Promise<Record<string, unknown>[]>;
247
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
248
+ workspaceId: () => Promise<string>;
249
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
250
+ } & {
251
+ slug: "reactionAdded";
252
+ };
253
+ export declare const reactionRemoved: {
254
+ slug: string;
255
+ label?: string;
256
+ description: string;
257
+ input: z.ZodObject<{
258
+ emojis: z.ZodDefault<z.ZodArray<z.ZodString>>;
259
+ user: z.ZodOptional<z.ZodString>;
260
+ channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
261
+ }, z.core.$strip>;
262
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
263
+ sample?: Record<string, unknown> | undefined;
264
+ } & {
265
+ type: "app";
266
+ event: string;
267
+ run(args: import("frogbot").PieceRunArgs<{
268
+ emojis: string[];
269
+ channels: string[];
270
+ user?: string | undefined;
271
+ }, {
272
+ signingSecret?: string | undefined;
273
+ }, {
274
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
275
+ [x: string]: unknown;
276
+ ok: true;
277
+ }>;
278
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
279
+ path: string;
280
+ method?: string;
281
+ body?: BodyInit | Record<string, unknown>;
282
+ headers?: HeadersInit;
283
+ token?: import("./client.js").SlackToken;
284
+ }) => Promise<{
285
+ status: number;
286
+ headers: {
287
+ [k: string]: string;
288
+ };
289
+ body: any;
290
+ }>;
291
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
292
+ path: string;
293
+ body?: Record<string, unknown>;
294
+ item: string;
295
+ token?: import("./client.js").SlackToken;
296
+ limit?: number;
297
+ }) => Promise<Record<string, unknown>[]>;
298
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
299
+ workspaceId: () => Promise<string>;
300
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
301
+ } & {
302
+ slug: "reactionRemoved";
303
+ };
304
+ export declare const channelCreated: {
305
+ slug: string;
306
+ label?: string;
307
+ description: string;
308
+ input: z.ZodObject<{}, z.core.$strip>;
309
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
310
+ sample?: Record<string, unknown> | undefined;
311
+ } & {
312
+ type: "app";
313
+ event: string;
314
+ run(args: import("frogbot").PieceRunArgs<Record<string, never>, {
315
+ signingSecret?: string | undefined;
316
+ }, {
317
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
318
+ [x: string]: unknown;
319
+ ok: true;
320
+ }>;
321
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
322
+ path: string;
323
+ method?: string;
324
+ body?: BodyInit | Record<string, unknown>;
325
+ headers?: HeadersInit;
326
+ token?: import("./client.js").SlackToken;
327
+ }) => Promise<{
328
+ status: number;
329
+ headers: {
330
+ [k: string]: string;
331
+ };
332
+ body: any;
333
+ }>;
334
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
335
+ path: string;
336
+ body?: Record<string, unknown>;
337
+ item: string;
338
+ token?: import("./client.js").SlackToken;
339
+ limit?: number;
340
+ }) => Promise<Record<string, unknown>[]>;
341
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
342
+ workspaceId: () => Promise<string>;
343
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
344
+ } & {
345
+ slug: "channelCreated";
346
+ };
347
+ export declare const channelCommandCreated: {
348
+ slug: string;
349
+ label?: string;
350
+ description: string;
351
+ input: z.ZodObject<{
352
+ user: z.ZodString;
353
+ commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
354
+ channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
355
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
356
+ }, z.core.$strip>;
357
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
358
+ sample?: Record<string, unknown> | undefined;
359
+ } & {
360
+ type: "app";
361
+ event: string;
362
+ run(args: import("frogbot").PieceRunArgs<{
363
+ user: string;
364
+ commands: string[];
365
+ channels: string[];
366
+ ignoreBots: boolean;
367
+ }, {
368
+ signingSecret?: string | undefined;
369
+ }, {
370
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
371
+ [x: string]: unknown;
372
+ ok: true;
373
+ }>;
374
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
375
+ path: string;
376
+ method?: string;
377
+ body?: BodyInit | Record<string, unknown>;
378
+ headers?: HeadersInit;
379
+ token?: import("./client.js").SlackToken;
380
+ }) => Promise<{
381
+ status: number;
382
+ headers: {
383
+ [k: string]: string;
384
+ };
385
+ body: any;
386
+ }>;
387
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
388
+ path: string;
389
+ body?: Record<string, unknown>;
390
+ item: string;
391
+ token?: import("./client.js").SlackToken;
392
+ limit?: number;
393
+ }) => Promise<Record<string, unknown>[]>;
394
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
395
+ workspaceId: () => Promise<string>;
396
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
397
+ } & {
398
+ slug: "channelCommandCreated";
399
+ };
400
+ export declare const directMentionCreated: {
401
+ slug: string;
402
+ label?: string;
403
+ description: string;
404
+ input: z.ZodObject<{
405
+ ignoreSelfMessages: z.ZodDefault<z.ZodBoolean>;
406
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
407
+ user: z.ZodString;
408
+ }, z.core.$strip>;
409
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
410
+ sample?: Record<string, unknown> | undefined;
411
+ } & {
412
+ type: "app";
413
+ event: string;
414
+ run(args: import("frogbot").PieceRunArgs<{
415
+ ignoreSelfMessages: boolean;
416
+ ignoreBots: boolean;
417
+ user: string;
418
+ }, {
419
+ signingSecret?: string | undefined;
420
+ }, {
421
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
422
+ [x: string]: unknown;
423
+ ok: true;
424
+ }>;
425
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
426
+ path: string;
427
+ method?: string;
428
+ body?: BodyInit | Record<string, unknown>;
429
+ headers?: HeadersInit;
430
+ token?: import("./client.js").SlackToken;
431
+ }) => Promise<{
432
+ status: number;
433
+ headers: {
434
+ [k: string]: string;
435
+ };
436
+ body: any;
437
+ }>;
438
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
439
+ path: string;
440
+ body?: Record<string, unknown>;
441
+ item: string;
442
+ token?: import("./client.js").SlackToken;
443
+ limit?: number;
444
+ }) => Promise<Record<string, unknown>[]>;
445
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
446
+ workspaceId: () => Promise<string>;
447
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
448
+ } & {
449
+ slug: "directMentionCreated";
450
+ };
451
+ export declare const directCommandCreated: {
452
+ slug: string;
453
+ label?: string;
454
+ description: string;
455
+ input: z.ZodObject<{
456
+ user: z.ZodString;
457
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
458
+ commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
459
+ ignoreSelfMessages: z.ZodDefault<z.ZodBoolean>;
460
+ }, z.core.$strip>;
461
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
462
+ sample?: Record<string, unknown> | undefined;
463
+ } & {
464
+ type: "app";
465
+ event: string;
466
+ run(args: import("frogbot").PieceRunArgs<{
467
+ user: string;
468
+ ignoreBots: boolean;
469
+ commands: string[];
470
+ ignoreSelfMessages: boolean;
471
+ }, {
472
+ signingSecret?: string | undefined;
473
+ }, {
474
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
475
+ [x: string]: unknown;
476
+ ok: true;
477
+ }>;
478
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
479
+ path: string;
480
+ method?: string;
481
+ body?: BodyInit | Record<string, unknown>;
482
+ headers?: HeadersInit;
483
+ token?: import("./client.js").SlackToken;
484
+ }) => Promise<{
485
+ status: number;
486
+ headers: {
487
+ [k: string]: string;
488
+ };
489
+ body: any;
490
+ }>;
491
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
492
+ path: string;
493
+ body?: Record<string, unknown>;
494
+ item: string;
495
+ token?: import("./client.js").SlackToken;
496
+ limit?: number;
497
+ }) => Promise<Record<string, unknown>[]>;
498
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
499
+ workspaceId: () => Promise<string>;
500
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
501
+ } & {
502
+ slug: "directCommandCreated";
503
+ };
504
+ export declare const userJoined: {
505
+ slug: string;
506
+ label?: string;
507
+ description: string;
508
+ input: z.ZodObject<{}, z.core.$strip>;
509
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
510
+ sample?: Record<string, unknown> | undefined;
511
+ } & {
512
+ type: "app";
513
+ event: string;
514
+ run(args: import("frogbot").PieceRunArgs<Record<string, never>, {
515
+ signingSecret?: string | undefined;
516
+ }, {
517
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
518
+ [x: string]: unknown;
519
+ ok: true;
520
+ }>;
521
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
522
+ path: string;
523
+ method?: string;
524
+ body?: BodyInit | Record<string, unknown>;
525
+ headers?: HeadersInit;
526
+ token?: import("./client.js").SlackToken;
527
+ }) => Promise<{
528
+ status: number;
529
+ headers: {
530
+ [k: string]: string;
531
+ };
532
+ body: any;
533
+ }>;
534
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
535
+ path: string;
536
+ body?: Record<string, unknown>;
537
+ item: string;
538
+ token?: import("./client.js").SlackToken;
539
+ limit?: number;
540
+ }) => Promise<Record<string, unknown>[]>;
541
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
542
+ workspaceId: () => Promise<string>;
543
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
544
+ } & {
545
+ slug: "userJoined";
546
+ };
547
+ export declare const messageSaved: {
548
+ slug: string;
549
+ label?: string;
550
+ description: string;
551
+ input: z.ZodObject<{}, z.core.$strip>;
552
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
553
+ sample?: Record<string, unknown> | undefined;
554
+ } & {
555
+ type: "app";
556
+ event: string;
557
+ run(args: import("frogbot").PieceRunArgs<Record<string, never>, {
558
+ signingSecret?: string | undefined;
559
+ }, {
560
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
561
+ [x: string]: unknown;
562
+ ok: true;
563
+ }>;
564
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
565
+ path: string;
566
+ method?: string;
567
+ body?: BodyInit | Record<string, unknown>;
568
+ headers?: HeadersInit;
569
+ token?: import("./client.js").SlackToken;
570
+ }) => Promise<{
571
+ status: number;
572
+ headers: {
573
+ [k: string]: string;
574
+ };
575
+ body: any;
576
+ }>;
577
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
578
+ path: string;
579
+ body?: Record<string, unknown>;
580
+ item: string;
581
+ token?: import("./client.js").SlackToken;
582
+ limit?: number;
583
+ }) => Promise<Record<string, unknown>[]>;
584
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
585
+ workspaceId: () => Promise<string>;
586
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
587
+ } & {
588
+ slug: "messageSaved";
589
+ };
590
+ export declare const customEmojiAdded: {
591
+ slug: string;
592
+ label?: string;
593
+ description: string;
594
+ input: z.ZodObject<{}, z.core.$strip>;
595
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
596
+ sample?: Record<string, unknown> | undefined;
597
+ } & {
598
+ type: "app";
599
+ event: string;
600
+ run(args: import("frogbot").PieceRunArgs<Record<string, never>, {
601
+ signingSecret?: string | undefined;
602
+ }, {
603
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
604
+ [x: string]: unknown;
605
+ ok: true;
606
+ }>;
607
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
608
+ path: string;
609
+ method?: string;
610
+ body?: BodyInit | Record<string, unknown>;
611
+ headers?: HeadersInit;
612
+ token?: import("./client.js").SlackToken;
613
+ }) => Promise<{
614
+ status: number;
615
+ headers: {
616
+ [k: string]: string;
617
+ };
618
+ body: any;
619
+ }>;
620
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
621
+ path: string;
622
+ body?: Record<string, unknown>;
623
+ item: string;
624
+ token?: import("./client.js").SlackToken;
625
+ limit?: number;
626
+ }) => Promise<Record<string, unknown>[]>;
627
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
628
+ workspaceId: () => Promise<string>;
629
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
630
+ } & {
631
+ slug: "customEmojiAdded";
632
+ };
633
+ export declare const modalInteraction: {
634
+ slug: string;
635
+ label?: string;
636
+ description: string;
637
+ input: z.ZodObject<{
638
+ interactionType: z.ZodDefault<z.ZodEnum<{
639
+ view_submission: "view_submission";
640
+ view_closed: "view_closed";
641
+ }>>;
642
+ }, z.core.$strip>;
643
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
644
+ sample?: Record<string, unknown> | undefined;
645
+ } & {
646
+ type: "app";
647
+ event: string;
648
+ run(args: import("frogbot").PieceRunArgs<{
649
+ interactionType: "view_submission" | "view_closed";
650
+ }, {
651
+ signingSecret?: string | undefined;
652
+ }, {
653
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
654
+ [x: string]: unknown;
655
+ ok: true;
656
+ }>;
657
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
658
+ path: string;
659
+ method?: string;
660
+ body?: BodyInit | Record<string, unknown>;
661
+ headers?: HeadersInit;
662
+ token?: import("./client.js").SlackToken;
663
+ }) => Promise<{
664
+ status: number;
665
+ headers: {
666
+ [k: string]: string;
667
+ };
668
+ body: any;
669
+ }>;
670
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
671
+ path: string;
672
+ body?: Record<string, unknown>;
673
+ item: string;
674
+ token?: import("./client.js").SlackToken;
675
+ limit?: number;
676
+ }) => Promise<Record<string, unknown>[]>;
677
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
678
+ workspaceId: () => Promise<string>;
679
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
680
+ } & {
681
+ slug: "modalInteraction";
682
+ };
683
+ export declare const slackTriggers: (({
684
+ slug: string;
685
+ label?: string;
686
+ description: string;
687
+ input: z.ZodObject<{
688
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
689
+ }, z.core.$strip>;
690
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
691
+ sample?: Record<string, unknown> | undefined;
692
+ } & {
693
+ type: "app";
694
+ event: string;
695
+ run(args: import("frogbot").PieceRunArgs<{
696
+ ignoreBots: boolean;
697
+ }, {
698
+ signingSecret?: string | undefined;
699
+ }, {
700
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
701
+ [x: string]: unknown;
702
+ ok: true;
703
+ }>;
704
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
705
+ path: string;
706
+ method?: string;
707
+ body?: BodyInit | Record<string, unknown>;
708
+ headers?: HeadersInit;
709
+ token?: import("./client.js").SlackToken;
710
+ }) => Promise<{
711
+ status: number;
712
+ headers: {
713
+ [k: string]: string;
714
+ };
715
+ body: any;
716
+ }>;
717
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
718
+ path: string;
719
+ body?: Record<string, unknown>;
720
+ item: string;
721
+ token?: import("./client.js").SlackToken;
722
+ limit?: number;
723
+ }) => Promise<Record<string, unknown>[]>;
724
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
725
+ workspaceId: () => Promise<string>;
726
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
727
+ } & {
728
+ slug: "messageCreated";
729
+ }) | ({
730
+ slug: string;
731
+ label?: string;
732
+ description: string;
733
+ input: z.ZodObject<{
734
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
735
+ channel: z.ZodString;
736
+ }, z.core.$strip>;
737
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
738
+ sample?: Record<string, unknown> | undefined;
739
+ } & {
740
+ type: "app";
741
+ event: string;
742
+ run(args: import("frogbot").PieceRunArgs<{
743
+ ignoreBots: boolean;
744
+ channel: string;
745
+ }, {
746
+ signingSecret?: string | undefined;
747
+ }, {
748
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
749
+ [x: string]: unknown;
750
+ ok: true;
751
+ }>;
752
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
753
+ path: string;
754
+ method?: string;
755
+ body?: BodyInit | Record<string, unknown>;
756
+ headers?: HeadersInit;
757
+ token?: import("./client.js").SlackToken;
758
+ }) => Promise<{
759
+ status: number;
760
+ headers: {
761
+ [k: string]: string;
762
+ };
763
+ body: any;
764
+ }>;
765
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
766
+ path: string;
767
+ body?: Record<string, unknown>;
768
+ item: string;
769
+ token?: import("./client.js").SlackToken;
770
+ limit?: number;
771
+ }) => Promise<Record<string, unknown>[]>;
772
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
773
+ workspaceId: () => Promise<string>;
774
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
775
+ } & {
776
+ slug: "channelMessageCreated";
777
+ }) | ({
778
+ slug: string;
779
+ label?: string;
780
+ description: string;
781
+ input: z.ZodObject<{
782
+ ignoreSelfMessages: z.ZodDefault<z.ZodBoolean>;
783
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
784
+ }, z.core.$strip>;
785
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
786
+ sample?: Record<string, unknown> | undefined;
787
+ } & {
788
+ type: "app";
789
+ event: string;
790
+ run(args: import("frogbot").PieceRunArgs<{
791
+ ignoreSelfMessages: boolean;
792
+ ignoreBots: boolean;
793
+ }, {
794
+ signingSecret?: string | undefined;
795
+ }, {
796
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
797
+ [x: string]: unknown;
798
+ ok: true;
799
+ }>;
800
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
801
+ path: string;
802
+ method?: string;
803
+ body?: BodyInit | Record<string, unknown>;
804
+ headers?: HeadersInit;
805
+ token?: import("./client.js").SlackToken;
806
+ }) => Promise<{
807
+ status: number;
808
+ headers: {
809
+ [k: string]: string;
810
+ };
811
+ body: any;
812
+ }>;
813
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
814
+ path: string;
815
+ body?: Record<string, unknown>;
816
+ item: string;
817
+ token?: import("./client.js").SlackToken;
818
+ limit?: number;
819
+ }) => Promise<Record<string, unknown>[]>;
820
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
821
+ workspaceId: () => Promise<string>;
822
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
823
+ } & {
824
+ slug: "directMessageCreated";
825
+ }) | ({
826
+ slug: string;
827
+ label?: string;
828
+ description: string;
829
+ input: z.ZodObject<{
830
+ users: z.ZodDefault<z.ZodArray<z.ZodString>>;
831
+ userGroups: z.ZodDefault<z.ZodArray<z.ZodString>>;
832
+ channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
833
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
834
+ removeMention: z.ZodDefault<z.ZodBoolean>;
835
+ }, z.core.$strip>;
836
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
837
+ sample?: Record<string, unknown> | undefined;
838
+ } & {
839
+ type: "app";
840
+ event: string;
841
+ run(args: import("frogbot").PieceRunArgs<{
842
+ users: string[];
843
+ userGroups: string[];
844
+ channels: string[];
845
+ ignoreBots: boolean;
846
+ removeMention: boolean;
847
+ }, {
848
+ signingSecret?: string | undefined;
849
+ }, {
850
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
851
+ [x: string]: unknown;
852
+ ok: true;
853
+ }>;
854
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
855
+ path: string;
856
+ method?: string;
857
+ body?: BodyInit | Record<string, unknown>;
858
+ headers?: HeadersInit;
859
+ token?: import("./client.js").SlackToken;
860
+ }) => Promise<{
861
+ status: number;
862
+ headers: {
863
+ [k: string]: string;
864
+ };
865
+ body: any;
866
+ }>;
867
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
868
+ path: string;
869
+ body?: Record<string, unknown>;
870
+ item: string;
871
+ token?: import("./client.js").SlackToken;
872
+ limit?: number;
873
+ }) => Promise<Record<string, unknown>[]>;
874
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
875
+ workspaceId: () => Promise<string>;
876
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
877
+ } & {
878
+ slug: "channelMentionCreated";
879
+ }) | ({
880
+ slug: string;
881
+ label?: string;
882
+ description: string;
883
+ input: z.ZodObject<{
884
+ emojis: z.ZodDefault<z.ZodArray<z.ZodString>>;
885
+ user: z.ZodOptional<z.ZodString>;
886
+ channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
887
+ }, z.core.$strip>;
888
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
889
+ sample?: Record<string, unknown> | undefined;
890
+ } & {
891
+ type: "app";
892
+ event: string;
893
+ run(args: import("frogbot").PieceRunArgs<{
894
+ emojis: string[];
895
+ channels: string[];
896
+ user?: string | undefined;
897
+ }, {
898
+ signingSecret?: string | undefined;
899
+ }, {
900
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
901
+ [x: string]: unknown;
902
+ ok: true;
903
+ }>;
904
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
905
+ path: string;
906
+ method?: string;
907
+ body?: BodyInit | Record<string, unknown>;
908
+ headers?: HeadersInit;
909
+ token?: import("./client.js").SlackToken;
910
+ }) => Promise<{
911
+ status: number;
912
+ headers: {
913
+ [k: string]: string;
914
+ };
915
+ body: any;
916
+ }>;
917
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
918
+ path: string;
919
+ body?: Record<string, unknown>;
920
+ item: string;
921
+ token?: import("./client.js").SlackToken;
922
+ limit?: number;
923
+ }) => Promise<Record<string, unknown>[]>;
924
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
925
+ workspaceId: () => Promise<string>;
926
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
927
+ } & {
928
+ slug: "reactionAdded";
929
+ }) | ({
930
+ slug: string;
931
+ label?: string;
932
+ description: string;
933
+ input: z.ZodObject<{
934
+ emojis: z.ZodDefault<z.ZodArray<z.ZodString>>;
935
+ user: z.ZodOptional<z.ZodString>;
936
+ channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
937
+ }, z.core.$strip>;
938
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
939
+ sample?: Record<string, unknown> | undefined;
940
+ } & {
941
+ type: "app";
942
+ event: string;
943
+ run(args: import("frogbot").PieceRunArgs<{
944
+ emojis: string[];
945
+ channels: string[];
946
+ user?: string | undefined;
947
+ }, {
948
+ signingSecret?: string | undefined;
949
+ }, {
950
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
951
+ [x: string]: unknown;
952
+ ok: true;
953
+ }>;
954
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
955
+ path: string;
956
+ method?: string;
957
+ body?: BodyInit | Record<string, unknown>;
958
+ headers?: HeadersInit;
959
+ token?: import("./client.js").SlackToken;
960
+ }) => Promise<{
961
+ status: number;
962
+ headers: {
963
+ [k: string]: string;
964
+ };
965
+ body: any;
966
+ }>;
967
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
968
+ path: string;
969
+ body?: Record<string, unknown>;
970
+ item: string;
971
+ token?: import("./client.js").SlackToken;
972
+ limit?: number;
973
+ }) => Promise<Record<string, unknown>[]>;
974
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
975
+ workspaceId: () => Promise<string>;
976
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
977
+ } & {
978
+ slug: "reactionRemoved";
979
+ }) | ({
980
+ slug: string;
981
+ label?: string;
982
+ description: string;
983
+ input: z.ZodObject<{}, z.core.$strip>;
984
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
985
+ sample?: Record<string, unknown> | undefined;
986
+ } & {
987
+ type: "app";
988
+ event: string;
989
+ run(args: import("frogbot").PieceRunArgs<Record<string, never>, {
990
+ signingSecret?: string | undefined;
991
+ }, {
992
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
993
+ [x: string]: unknown;
994
+ ok: true;
995
+ }>;
996
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
997
+ path: string;
998
+ method?: string;
999
+ body?: BodyInit | Record<string, unknown>;
1000
+ headers?: HeadersInit;
1001
+ token?: import("./client.js").SlackToken;
1002
+ }) => Promise<{
1003
+ status: number;
1004
+ headers: {
1005
+ [k: string]: string;
1006
+ };
1007
+ body: any;
1008
+ }>;
1009
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
1010
+ path: string;
1011
+ body?: Record<string, unknown>;
1012
+ item: string;
1013
+ token?: import("./client.js").SlackToken;
1014
+ limit?: number;
1015
+ }) => Promise<Record<string, unknown>[]>;
1016
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
1017
+ workspaceId: () => Promise<string>;
1018
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
1019
+ } & {
1020
+ slug: "channelCreated";
1021
+ }) | ({
1022
+ slug: string;
1023
+ label?: string;
1024
+ description: string;
1025
+ input: z.ZodObject<{
1026
+ user: z.ZodString;
1027
+ commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
1028
+ channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
1029
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
1030
+ }, z.core.$strip>;
1031
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
1032
+ sample?: Record<string, unknown> | undefined;
1033
+ } & {
1034
+ type: "app";
1035
+ event: string;
1036
+ run(args: import("frogbot").PieceRunArgs<{
1037
+ user: string;
1038
+ commands: string[];
1039
+ channels: string[];
1040
+ ignoreBots: boolean;
1041
+ }, {
1042
+ signingSecret?: string | undefined;
1043
+ }, {
1044
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
1045
+ [x: string]: unknown;
1046
+ ok: true;
1047
+ }>;
1048
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
1049
+ path: string;
1050
+ method?: string;
1051
+ body?: BodyInit | Record<string, unknown>;
1052
+ headers?: HeadersInit;
1053
+ token?: import("./client.js").SlackToken;
1054
+ }) => Promise<{
1055
+ status: number;
1056
+ headers: {
1057
+ [k: string]: string;
1058
+ };
1059
+ body: any;
1060
+ }>;
1061
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
1062
+ path: string;
1063
+ body?: Record<string, unknown>;
1064
+ item: string;
1065
+ token?: import("./client.js").SlackToken;
1066
+ limit?: number;
1067
+ }) => Promise<Record<string, unknown>[]>;
1068
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
1069
+ workspaceId: () => Promise<string>;
1070
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
1071
+ } & {
1072
+ slug: "channelCommandCreated";
1073
+ }) | ({
1074
+ slug: string;
1075
+ label?: string;
1076
+ description: string;
1077
+ input: z.ZodObject<{
1078
+ ignoreSelfMessages: z.ZodDefault<z.ZodBoolean>;
1079
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
1080
+ user: z.ZodString;
1081
+ }, z.core.$strip>;
1082
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
1083
+ sample?: Record<string, unknown> | undefined;
1084
+ } & {
1085
+ type: "app";
1086
+ event: string;
1087
+ run(args: import("frogbot").PieceRunArgs<{
1088
+ ignoreSelfMessages: boolean;
1089
+ ignoreBots: boolean;
1090
+ user: string;
1091
+ }, {
1092
+ signingSecret?: string | undefined;
1093
+ }, {
1094
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
1095
+ [x: string]: unknown;
1096
+ ok: true;
1097
+ }>;
1098
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
1099
+ path: string;
1100
+ method?: string;
1101
+ body?: BodyInit | Record<string, unknown>;
1102
+ headers?: HeadersInit;
1103
+ token?: import("./client.js").SlackToken;
1104
+ }) => Promise<{
1105
+ status: number;
1106
+ headers: {
1107
+ [k: string]: string;
1108
+ };
1109
+ body: any;
1110
+ }>;
1111
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
1112
+ path: string;
1113
+ body?: Record<string, unknown>;
1114
+ item: string;
1115
+ token?: import("./client.js").SlackToken;
1116
+ limit?: number;
1117
+ }) => Promise<Record<string, unknown>[]>;
1118
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
1119
+ workspaceId: () => Promise<string>;
1120
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
1121
+ } & {
1122
+ slug: "directMentionCreated";
1123
+ }) | ({
1124
+ slug: string;
1125
+ label?: string;
1126
+ description: string;
1127
+ input: z.ZodObject<{
1128
+ user: z.ZodString;
1129
+ ignoreBots: z.ZodDefault<z.ZodBoolean>;
1130
+ commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
1131
+ ignoreSelfMessages: z.ZodDefault<z.ZodBoolean>;
1132
+ }, z.core.$strip>;
1133
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
1134
+ sample?: Record<string, unknown> | undefined;
1135
+ } & {
1136
+ type: "app";
1137
+ event: string;
1138
+ run(args: import("frogbot").PieceRunArgs<{
1139
+ user: string;
1140
+ ignoreBots: boolean;
1141
+ commands: string[];
1142
+ ignoreSelfMessages: boolean;
1143
+ }, {
1144
+ signingSecret?: string | undefined;
1145
+ }, {
1146
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
1147
+ [x: string]: unknown;
1148
+ ok: true;
1149
+ }>;
1150
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
1151
+ path: string;
1152
+ method?: string;
1153
+ body?: BodyInit | Record<string, unknown>;
1154
+ headers?: HeadersInit;
1155
+ token?: import("./client.js").SlackToken;
1156
+ }) => Promise<{
1157
+ status: number;
1158
+ headers: {
1159
+ [k: string]: string;
1160
+ };
1161
+ body: any;
1162
+ }>;
1163
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
1164
+ path: string;
1165
+ body?: Record<string, unknown>;
1166
+ item: string;
1167
+ token?: import("./client.js").SlackToken;
1168
+ limit?: number;
1169
+ }) => Promise<Record<string, unknown>[]>;
1170
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
1171
+ workspaceId: () => Promise<string>;
1172
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
1173
+ } & {
1174
+ slug: "directCommandCreated";
1175
+ }) | ({
1176
+ slug: string;
1177
+ label?: string;
1178
+ description: string;
1179
+ input: z.ZodObject<{}, z.core.$strip>;
1180
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
1181
+ sample?: Record<string, unknown> | undefined;
1182
+ } & {
1183
+ type: "app";
1184
+ event: string;
1185
+ run(args: import("frogbot").PieceRunArgs<Record<string, never>, {
1186
+ signingSecret?: string | undefined;
1187
+ }, {
1188
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
1189
+ [x: string]: unknown;
1190
+ ok: true;
1191
+ }>;
1192
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
1193
+ path: string;
1194
+ method?: string;
1195
+ body?: BodyInit | Record<string, unknown>;
1196
+ headers?: HeadersInit;
1197
+ token?: import("./client.js").SlackToken;
1198
+ }) => Promise<{
1199
+ status: number;
1200
+ headers: {
1201
+ [k: string]: string;
1202
+ };
1203
+ body: any;
1204
+ }>;
1205
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
1206
+ path: string;
1207
+ body?: Record<string, unknown>;
1208
+ item: string;
1209
+ token?: import("./client.js").SlackToken;
1210
+ limit?: number;
1211
+ }) => Promise<Record<string, unknown>[]>;
1212
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
1213
+ workspaceId: () => Promise<string>;
1214
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
1215
+ } & {
1216
+ slug: "userJoined";
1217
+ }) | ({
1218
+ slug: string;
1219
+ label?: string;
1220
+ description: string;
1221
+ input: z.ZodObject<{}, z.core.$strip>;
1222
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
1223
+ sample?: Record<string, unknown> | undefined;
1224
+ } & {
1225
+ type: "app";
1226
+ event: string;
1227
+ run(args: import("frogbot").PieceRunArgs<Record<string, never>, {
1228
+ signingSecret?: string | undefined;
1229
+ }, {
1230
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
1231
+ [x: string]: unknown;
1232
+ ok: true;
1233
+ }>;
1234
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
1235
+ path: string;
1236
+ method?: string;
1237
+ body?: BodyInit | Record<string, unknown>;
1238
+ headers?: HeadersInit;
1239
+ token?: import("./client.js").SlackToken;
1240
+ }) => Promise<{
1241
+ status: number;
1242
+ headers: {
1243
+ [k: string]: string;
1244
+ };
1245
+ body: any;
1246
+ }>;
1247
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
1248
+ path: string;
1249
+ body?: Record<string, unknown>;
1250
+ item: string;
1251
+ token?: import("./client.js").SlackToken;
1252
+ limit?: number;
1253
+ }) => Promise<Record<string, unknown>[]>;
1254
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
1255
+ workspaceId: () => Promise<string>;
1256
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
1257
+ } & {
1258
+ slug: "messageSaved";
1259
+ }) | ({
1260
+ slug: string;
1261
+ label?: string;
1262
+ description: string;
1263
+ input: z.ZodObject<{}, z.core.$strip>;
1264
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
1265
+ sample?: Record<string, unknown> | undefined;
1266
+ } & {
1267
+ type: "app";
1268
+ event: string;
1269
+ run(args: import("frogbot").PieceRunArgs<Record<string, never>, {
1270
+ signingSecret?: string | undefined;
1271
+ }, {
1272
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
1273
+ [x: string]: unknown;
1274
+ ok: true;
1275
+ }>;
1276
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
1277
+ path: string;
1278
+ method?: string;
1279
+ body?: BodyInit | Record<string, unknown>;
1280
+ headers?: HeadersInit;
1281
+ token?: import("./client.js").SlackToken;
1282
+ }) => Promise<{
1283
+ status: number;
1284
+ headers: {
1285
+ [k: string]: string;
1286
+ };
1287
+ body: any;
1288
+ }>;
1289
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
1290
+ path: string;
1291
+ body?: Record<string, unknown>;
1292
+ item: string;
1293
+ token?: import("./client.js").SlackToken;
1294
+ limit?: number;
1295
+ }) => Promise<Record<string, unknown>[]>;
1296
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
1297
+ workspaceId: () => Promise<string>;
1298
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
1299
+ } & {
1300
+ slug: "customEmojiAdded";
1301
+ }) | ({
1302
+ slug: string;
1303
+ label?: string;
1304
+ description: string;
1305
+ input: z.ZodObject<{
1306
+ interactionType: z.ZodDefault<z.ZodEnum<{
1307
+ view_submission: "view_submission";
1308
+ view_closed: "view_closed";
1309
+ }>>;
1310
+ }, z.core.$strip>;
1311
+ output?: z.ZodRecord<z.ZodString, z.ZodUnknown> | undefined;
1312
+ sample?: Record<string, unknown> | undefined;
1313
+ } & {
1314
+ type: "app";
1315
+ event: string;
1316
+ run(args: import("frogbot").PieceRunArgs<{
1317
+ interactionType: "view_submission" | "view_closed";
1318
+ }, {
1319
+ signingSecret?: string | undefined;
1320
+ }, {
1321
+ request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
1322
+ [x: string]: unknown;
1323
+ ok: true;
1324
+ }>;
1325
+ raw: ({ path, method, body, headers, token: tokenKind, }: {
1326
+ path: string;
1327
+ method?: string;
1328
+ body?: BodyInit | Record<string, unknown>;
1329
+ headers?: HeadersInit;
1330
+ token?: import("./client.js").SlackToken;
1331
+ }) => Promise<{
1332
+ status: number;
1333
+ headers: {
1334
+ [k: string]: string;
1335
+ };
1336
+ body: any;
1337
+ }>;
1338
+ paginate: ({ path, body, item, token: tokenKind, limit, }: {
1339
+ path: string;
1340
+ body?: Record<string, unknown>;
1341
+ item: string;
1342
+ token?: import("./client.js").SlackToken;
1343
+ limit?: number;
1344
+ }) => Promise<Record<string, unknown>[]>;
1345
+ token: (kind?: import("./client.js").SlackToken) => string | undefined;
1346
+ workspaceId: () => Promise<string>;
1347
+ }>): Promise<import("frogbot").TriggerEvent<Record<string, unknown>>[]>;
1348
+ } & {
1349
+ slug: "modalInteraction";
1350
+ }))[];
592
1351
  //# sourceMappingURL=triggers.d.ts.map