@frogbotai/piece-slack 0.22.0 → 0.24.0

package/dist/index.d.ts

@@ -1,62 +1,1011 @@
-import { type PieceFactoryConfig } from 'frogbot/pieces';
-export declare const slackActions: readonly ["slack-add-reaction-to-message", "send_direct_message", "send_channel_message", "uploadFile", "get-file", "searchMessages", "slack-find-user-by-email", "find-user-by-id", "updateMessage", "delete-message"];
-export declare const slackScopes: readonly ["channels:read", "channels:manage", "channels:history", "chat:write", "groups:read", "groups:write", "groups:history", "reactions:read", "mpim:read", "mpim:write", "mpim:history", "im:write", "im:read", "im:history", "users:read", "files:write", "files:read", "users:read.email", "reactions:write", "usergroups:read", "usergroups:write", "chat:write.customize", "links:read", "links:write", "emoji:read", "users.profile:read", "channels:write.invites", "groups:write.invites", "channels:join", "conversations.connect:write"];
-export declare function createSlack(config?: PieceFactoryConfig): import("frogbot/pieces").Piece & {
-    /** Add Reaction to Message: Add an emoji reaction to a message. */
-    slackAddReactionToMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Message To A User: Send message to a user */
-    sendDirectMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Send Message To A Channel: Send message to a channel */
-    sendChannelMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Request Approval from A User: Send approval message to a user and then wait until the message is approved or disapproved */
-    requestApprovalDirectMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Request Approval in a Channel: Send approval message to a channel and then wait until the message is approved or disapproved */
-    requestApprovalMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Request Action from A User: Send a message to a user and wait until the user selects an action */
-    requestActionDirectMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Request Action in A Channel: Send a message in a channel and wait until an action is selected */
-    requestActionMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Upload file: Upload file without sharing it to a channel or user */
-    uploadFile: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Get File: Return information about a given file ID. */
-    getFile: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Search messages: Searches for messages matching a query */
-    searchMessages: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Find User by Email: Finds a user by matching against their email address. */
-    slackFindUserByEmail: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Find User by Handle: Finds a user by matching against their Slack handle. */
-    slackFindUserByHandle: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Find User by ID: Finds a user by their ID. */
-    findUserById: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** List users: List all users of the workspace */
-    listUsers: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Update message: Update an existing message */
-    updateMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Delete Message: Deletes a specific message from a channel using the message's timestamp. */
-    deleteMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Create Channel: Creates a new channel. */
-    slackCreateChannel: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Update Profile: Update basic profile field such as name or title. */
-    slackUpdateProfile: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Get channel history: Retrieve all messages from a specific channel ("conversation") between specified timestamps */
-    getChannelHistory: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Set User Status: Sets a user's custom status */
-    slackSetUserStatus: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Markdown to Slack format: Convert Markdown-formatted text to Slack's pseudo - markdown syntax */
-    markdownToSlackFormat: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Retrieve Thread Messages: Retrieves thread messages by channel and thread timestamp. */
-    retrieveThreadMessages: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Set Channel Topic: Sets the topic on a selected channel. */
-    setChannelTopic: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Get Message by Timestamp: Retrieves a specific message from a channel history using the message's timestamp. */
-    getMessage: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Invite User to Channel: Invites an existing User to an existing channel. */
-    inviteUserToChannel: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Get User Group by Handle: Finds a Slack user group by its handle (e.g., @user-group) and returns its details. To mention this group in a message, map the returned ID using the syntax <!subteam^ID>. Read more: https://api.slack.com/reference/surfaces/formatting#mentioning-groups */
-    getGroupByHandle: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Update User Group Members: Add users to or overwrite the member list of a Slack user group. */
-    updateGroupUsers: import("node_modules/frogbot/dist/tools/types").AnyTool;
-    /** Custom API Call: Make a custom API call to a specific endpoint */
-    customApiCall: import("node_modules/frogbot/dist/tools/types").AnyTool;
-};
+import type { z } from 'zod';
+import { createSlackClient } from './client.js';
+import { slackScopes } from './config.js';
+import { verifySlackWebhook } from './webhook.js';
+export declare const slackActionNames: string[];
+export declare const slackTriggerNames: string[];
+export { slackScopes };
+export declare const createSlack: import("frogbot").PieceFactory<{
+    readonly slug: "slack";
+    readonly label: "Slack";
+    readonly admin: {
+        readonly description: "Manage Slack messages, files, channels, users, groups, and workspace events";
+        readonly group: "Communication";
+    };
+    readonly auth: z.ZodObject<{
+        botToken: z.ZodString;
+        userToken: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly options: z.ZodObject<{
+        signingSecret: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly client: typeof createSlackClient;
+    readonly oauth: {
+        readonly authorizationUrl: "https://slack.com/oauth/v2/authorize";
+        readonly tokenUrl: "https://slack.com/api/oauth.v2.access";
+        readonly scopes: string[];
+        readonly params: {
+            readonly user_scope: "search:read,users.profile:write,reactions:read,reactions:write,im:history,stars:read,channels:write,groups:write,im:write,mpim:write,channels:write.invites,groups:write.invites,channels:history,groups:history,chat:write,users:read,usergroups:write";
+        };
+        readonly toAuth: ({ tokens }: {
+            tokens: import("frogbot").OAuthTokens;
+        }) => {
+            botToken: string;
+            userToken: string | undefined;
+            teamId: string | undefined;
+        };
+        readonly account: (args: {
+            tokens: import("frogbot").OAuthTokens;
+            client: {
+                request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+                    [x: string]: unknown;
+                    ok: true;
+                }>;
+                raw: ({ path, method, body, headers, token: tokenKind, }: {
+                    path: string;
+                    method?: string;
+                    body?: BodyInit | Record<string, unknown>;
+                    headers?: HeadersInit;
+                    token?: import("./client.js").SlackToken;
+                }) => Promise<{
+                    status: number;
+                    headers: {
+                        [k: string]: string;
+                    };
+                    body: any;
+                }>;
+                paginate: ({ path, body, item, token: tokenKind, limit, }: {
+                    path: string;
+                    body?: Record<string, unknown>;
+                    item: string;
+                    token?: import("./client.js").SlackToken;
+                    limit?: number;
+                }) => Promise<Record<string, unknown>[]>;
+                token: (kind?: import("./client.js").SlackToken) => string | undefined;
+                workspaceId: () => Promise<string>;
+            };
+            req: import("frogbot").FrogbotRequest;
+        }) => Promise<import("frogbot").PieceOAuthAccount>;
+    };
+    readonly webhook: {
+        verify: typeof verifySlackWebhook;
+        handshake({ req }: {
+            req: import("frogbot").FrogbotRequest;
+            options: {
+                signingSecret?: string | undefined;
+            };
+        }): Promise<Response | null>;
+        parse({ req }: {
+            req: import("frogbot").FrogbotRequest;
+        }): {
+            event: string;
+        };
+    };
+    readonly channel: {
+        adapter({ auth, options }: {
+            auth: {
+                botToken: string;
+                userToken?: string | undefined;
+                teamId?: string | undefined;
+            };
+            options: {
+                signingSecret?: string | undefined;
+            };
+        }): import("@chat-adapter/slack").SlackAdapter;
+        identity({ author, client, req }: {
+            author: import("chat").Author;
+            client: {
+                request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+                    [x: string]: unknown;
+                    ok: true;
+                }>;
+                raw: ({ path, method, body, headers, token: tokenKind, }: {
+                    path: string;
+                    method?: string;
+                    body?: BodyInit | Record<string, unknown>;
+                    headers?: HeadersInit;
+                    token?: import("./client.js").SlackToken;
+                }) => Promise<{
+                    status: number;
+                    headers: {
+                        [k: string]: string;
+                    };
+                    body: any;
+                }>;
+                paginate: ({ path, body, item, token: tokenKind, limit, }: {
+                    path: string;
+                    body?: Record<string, unknown>;
+                    item: string;
+                    token?: import("./client.js").SlackToken;
+                    limit?: number;
+                }) => Promise<Record<string, unknown>[]>;
+                token: (kind?: import("./client.js").SlackToken) => string | undefined;
+                workspaceId: () => Promise<string>;
+            };
+            req: import("frogbot").FrogbotRequest;
+        }): Promise<{
+            collection: string;
+            id: string | number;
+        } | null>;
+    };
+    readonly actions: (import("frogbot").PieceActionDefinition<z.ZodObject<{
+        text: z.ZodString;
+        username: z.ZodOptional<z.ZodString>;
+        profilePicture: z.ZodOptional<z.ZodURL>;
+        iconEmoji: z.ZodOptional<z.ZodString>;
+        blocks: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        unfurlLinks: z.ZodDefault<z.ZodBoolean>;
+        userId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        channel: z.ZodOptional<z.ZodString>;
+        ts: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+        channel?: string | undefined;
+        ts?: string | undefined;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        channel: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
+        sendAsBot: z.ZodDefault<z.ZodBoolean>;
+        threadTimestamp: z.ZodOptional<z.ZodString>;
+        username: z.ZodOptional<z.ZodString>;
+        profilePicture: z.ZodOptional<z.ZodURL>;
+        iconEmoji: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodObject<{
+            fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        replyBroadcast: z.ZodDefault<z.ZodBoolean>;
+        unfurlLinks: z.ZodDefault<z.ZodBoolean>;
+        blocks: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        file: z.ZodObject<{
+            fileId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        title: z.ZodOptional<z.ZodString>;
+        filename: z.ZodOptional<z.ZodString>;
+        channel: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        fileId: z.ZodString;
+    }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, Record<string, unknown>> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        query: z.ZodString;
+    }, z.core.$strip>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, Record<string, unknown>[]> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        email: z.ZodEmail;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        handle: z.ZodString;
+    }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, Record<string, unknown>> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        includeBots: z.ZodDefault<z.ZodBoolean>;
+        includeDisabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, Record<string, unknown>[]> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        channel: z.ZodString;
+        timestamp: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        channelName: z.ZodString;
+        isPrivate: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodEmail>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        channel: z.ZodString;
+        oldest: z.ZodOptional<z.ZodNumber>;
+        latest: z.ZodOptional<z.ZodNumber>;
+        inclusive: z.ZodDefault<z.ZodBoolean>;
+        includeAllMetadata: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, Record<string, unknown>[]> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        text: z.ZodString;
+        emoji: z.ZodOptional<z.ZodString>;
+        expiration: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        markdown: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strip>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        text: string;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        channel: z.ZodString;
+        threadTimestamp: z.ZodString;
+    }, z.core.$strip>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, Record<string, unknown>[]> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        channel: z.ZodString;
+        topic: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        channel: z.ZodString;
+        userId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        handle: z.ZodString;
+        userIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        appendUsers: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$catchall<z.ZodUnknown>>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        [x: string]: unknown;
+        ok: true;
+    }> | import("frogbot").PieceActionDefinition<z.ZodObject<{
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        queryParams: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        useUserToken: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodNumber;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        body: z.ZodUnknown;
+    }, z.core.$strip>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }, {
+        status: number;
+        headers: Record<string, string>;
+        body: unknown;
+    }>)[];
+    readonly triggers: (import("frogbot").PieceAppTrigger<z.ZodObject<{
+        ignoreBots: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }> | import("frogbot").PieceAppTrigger<z.ZodObject<{
+        emojis: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        user: z.ZodOptional<z.ZodString>;
+        channels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }> | import("frogbot").PieceAppTrigger<z.ZodObject<{}, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }> | import("frogbot").PieceAppTrigger<z.ZodObject<{
+        interactionType: z.ZodDefault<z.ZodEnum<{
+            view_submission: "view_submission";
+            view_closed: "view_closed";
+        }>>;
+    }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, {
+        signingSecret?: string;
+    }, {
+        request: (path: string, body?: Record<string, unknown>, tokenKind?: import("./client.js").SlackToken) => Promise<{
+            [x: string]: unknown;
+            ok: true;
+        }>;
+        raw: ({ path, method, body, headers, token: tokenKind, }: {
+            path: string;
+            method?: string;
+            body?: BodyInit | Record<string, unknown>;
+            headers?: HeadersInit;
+            token?: import("./client.js").SlackToken;
+        }) => Promise<{
+            status: number;
+            headers: {
+                [k: string]: string;
+            };
+            body: any;
+        }>;
+        paginate: ({ path, body, item, token: tokenKind, limit, }: {
+            path: string;
+            body?: Record<string, unknown>;
+            item: string;
+            token?: import("./client.js").SlackToken;
+            limit?: number;
+        }) => Promise<Record<string, unknown>[]>;
+        token: (kind?: import("./client.js").SlackToken) => string | undefined;
+        workspaceId: () => Promise<string>;
+    }>)[];
+}>;
 //# sourceMappingURL=index.d.ts.map