@mastra/connect 0.2.0 → 0.3.0

package/dist/providers/slack/tools/list-users.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listUsersInputSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listUsersOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        team_id: z.ZodString;
+        name: z.ZodString;
+        deleted: z.ZodBoolean;
+        real_name: z.ZodOptional<z.ZodString>;
+        profile: z.ZodObject<{
+            real_name: z.ZodOptional<z.ZodString>;
+            display_name: z.ZodOptional<z.ZodString>;
+            email: z.ZodOptional<z.ZodString>;
+            avatar_hash: z.ZodOptional<z.ZodString>;
+            image_24: z.ZodOptional<z.ZodString>;
+            image_32: z.ZodOptional<z.ZodString>;
+            image_48: z.ZodOptional<z.ZodString>;
+            image_72: z.ZodOptional<z.ZodString>;
+            image_192: z.ZodOptional<z.ZodString>;
+            image_512: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        is_admin: z.ZodBoolean;
+        is_owner: z.ZodBoolean;
+        is_bot: z.ZodBoolean;
+        updated: z.ZodNumber;
+    }, z.core.$strip>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listUsersTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+}, {
+    items: {
+        id: string;
+        team_id: string;
+        name: string;
+        deleted: boolean;
+        real_name?: string | undefined;
+        profile: {
+            [x: string]: unknown;
+            real_name?: string | undefined;
+            display_name?: string | undefined;
+            email?: string | undefined;
+            avatar_hash?: string | undefined;
+            image_24?: string | undefined;
+            image_32?: string | undefined;
+            image_48?: string | undefined;
+            image_72?: string | undefined;
+            image_192?: string | undefined;
+            image_512?: string | undefined;
+        };
+        is_admin: boolean;
+        is_owner: boolean;
+        is_bot: boolean;
+        updated: number;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_list_users", unknown>;
+//# sourceMappingURL=list-users.d.ts.map

package/dist/providers/slack/tools/list-users.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-users.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/list-users.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AA4BxE,eAAO,MAAM,oBAAoB;;iBAE/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;iBAGhC,CAAC;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;gIAyDjD"}

package/dist/providers/slack/tools/lookup-user-by-email.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const lookupUserByEmailInputSchema: z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>;
+export declare const lookupUserByEmailOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    team_id: z.ZodString;
+    name: z.ZodString;
+    real_name: z.ZodOptional<z.ZodString>;
+    email: z.ZodString;
+    is_admin: z.ZodBoolean;
+    is_bot: z.ZodBoolean;
+    is_restricted: z.ZodBoolean;
+    is_ultra_restricted: z.ZodBoolean;
+    is_deleted: z.ZodBoolean;
+    profile: z.ZodObject<{
+        avatar_hash: z.ZodOptional<z.ZodString>;
+        status_text: z.ZodOptional<z.ZodString>;
+        status_emoji: z.ZodOptional<z.ZodString>;
+        real_name: z.ZodOptional<z.ZodString>;
+        display_name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        image_24: z.ZodOptional<z.ZodString>;
+        image_32: z.ZodOptional<z.ZodString>;
+        image_48: z.ZodOptional<z.ZodString>;
+        image_72: z.ZodOptional<z.ZodString>;
+        image_192: z.ZodOptional<z.ZodString>;
+        image_512: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare function lookupUserByEmailTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    email: string;
+}, {
+    id: string;
+    team_id: string;
+    name: string;
+    real_name?: string | undefined;
+    email: string;
+    is_admin: boolean;
+    is_bot: boolean;
+    is_restricted: boolean;
+    is_ultra_restricted: boolean;
+    is_deleted: boolean;
+    profile: {
+        avatar_hash?: string | undefined;
+        status_text?: string | undefined;
+        status_emoji?: string | undefined;
+        real_name?: string | undefined;
+        display_name?: string | undefined;
+        email?: string | undefined;
+        image_24?: string | undefined;
+        image_32?: string | undefined;
+        image_48?: string | undefined;
+        image_72?: string | undefined;
+        image_192?: string | undefined;
+        image_512?: string | undefined;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_lookup_user_by_email", unknown>;
+//# sourceMappingURL=lookup-user-by-email.d.ts.map

package/dist/providers/slack/tools/lookup-user-by-email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup-user-by-email.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/lookup-user-by-email.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;0IAwDzD"}

package/dist/providers/slack/tools/mark-as-read.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const markAsReadInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    message_ts: z.ZodString;
+}, z.core.$strip>;
+export declare const markAsReadOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function markAsReadTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    message_ts: string;
+}, {
+    ok: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_mark_as_read", unknown>;
+//# sourceMappingURL=mark-as-read.d.ts.map

package/dist/providers/slack/tools/mark-as-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark-as-read.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/mark-as-read.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;iBAGhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;iBAEjC,CAAC;AAEH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;kIAkClD"}

package/dist/providers/slack/tools/open-dm.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const openDmInputSchema: z.ZodObject<{
+    user_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const openDmOutputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    channel_name: z.ZodString;
+}, z.core.$strip>;
+export declare function openDmTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    user_ids: string[];
+}, {
+    channel_id: string;
+    channel_name: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_open_dm", unknown>;
+//# sourceMappingURL=open-dm.d.ts.map

package/dist/providers/slack/tools/open-dm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-dm.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/open-dm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,iBAAiB;;iBAO5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa;;;;;6HA+B9C"}

package/dist/providers/slack/tools/pin-message.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const pinMessageInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    message_timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const pinMessageOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function pinMessageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    message_timestamp: string;
+}, {
+    ok: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_pin_message", unknown>;
+//# sourceMappingURL=pin-message.d.ts.map

package/dist/providers/slack/tools/pin-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pin-message.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/pin-message.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;iBAGhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;iBAEjC,CAAC;AAEH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;iIA+BlD"}

package/dist/providers/slack/tools/post-message.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const postMessageInputSchema: z.ZodObject<{
+    channel: z.ZodString;
+    text: z.ZodString;
+    thread_ts: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const postMessageOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    channel: z.ZodString;
+    ts: z.ZodString;
+    message: z.ZodObject<{
+        type: z.ZodString;
+        subtype: z.ZodOptional<z.ZodString>;
+        text: z.ZodString;
+        ts: z.ZodString;
+        username: z.ZodOptional<z.ZodString>;
+        bot_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare function postMessageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel: string;
+    text: string;
+    thread_ts?: string | undefined;
+}, {
+    ok: boolean;
+    channel: string;
+    ts: string;
+    message: {
+        type: string;
+        subtype?: string | undefined;
+        text: string;
+        ts: string;
+        username?: string | undefined;
+        bot_id?: string | undefined;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_post_message", unknown>;
+//# sourceMappingURL=post-message.d.ts.map

package/dist/providers/slack/tools/post-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-message.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/post-message.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;;iBAOjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAclC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;kIA8CnD"}

package/dist/providers/slack/tools/remove-from-channel.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const removeFromChannelInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    user_id: z.ZodString;
+}, z.core.$strip>;
+export declare const removeFromChannelOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function removeFromChannelTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    user_id: string;
+}, {
+    ok: boolean;
+    error?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_remove_from_channel", unknown>;
+//# sourceMappingURL=remove-from-channel.d.ts.map

package/dist/providers/slack/tools/remove-from-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-from-channel.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/remove-from-channel.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;iBAGxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;yIAgCzD"}

package/dist/providers/slack/tools/remove-reaction.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const removeReactionInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    timestamp: z.ZodString;
+    reaction_name: z.ZodString;
+}, z.core.$strip>;
+export declare const removeReactionOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function removeReactionTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    timestamp: string;
+    reaction_name: string;
+}, {
+    ok: boolean;
+    error?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_remove_reaction", unknown>;
+//# sourceMappingURL=remove-reaction.d.ts.map

package/dist/providers/slack/tools/remove-reaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-reaction.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/remove-reaction.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;qIAgCtD"}

package/dist/providers/slack/tools/rename-channel.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const renameChannelInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    channel_name: z.ZodString;
+}, z.core.$strip>;
+export declare const renameChannelOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    is_channel: z.ZodOptional<z.ZodBoolean>;
+    is_group: z.ZodOptional<z.ZodBoolean>;
+    is_im: z.ZodOptional<z.ZodBoolean>;
+    created: z.ZodOptional<z.ZodNumber>;
+    creator: z.ZodOptional<z.ZodString>;
+    is_archived: z.ZodOptional<z.ZodBoolean>;
+    is_general: z.ZodOptional<z.ZodBoolean>;
+    is_private: z.ZodOptional<z.ZodBoolean>;
+    is_member: z.ZodOptional<z.ZodBoolean>;
+    num_members: z.ZodOptional<z.ZodNumber>;
+    topic: z.ZodOptional<z.ZodObject<{
+        value: z.ZodOptional<z.ZodString>;
+        creator: z.ZodOptional<z.ZodString>;
+        last_set: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    purpose: z.ZodOptional<z.ZodObject<{
+        value: z.ZodOptional<z.ZodString>;
+        creator: z.ZodOptional<z.ZodString>;
+        last_set: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function renameChannelTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    channel_name: string;
+}, {
+    id: string;
+    name: string;
+    is_channel?: boolean | undefined;
+    is_group?: boolean | undefined;
+    is_im?: boolean | undefined;
+    created?: number | undefined;
+    creator?: string | undefined;
+    is_archived?: boolean | undefined;
+    is_general?: boolean | undefined;
+    is_private?: boolean | undefined;
+    is_member?: boolean | undefined;
+    num_members?: number | undefined;
+    topic?: {
+        value?: string | undefined;
+        creator?: string | undefined;
+        last_set?: number | undefined;
+    } | undefined;
+    purpose?: {
+        value?: string | undefined;
+        creator?: string | undefined;
+        last_set?: number | undefined;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_rename_channel", unknown>;
+//# sourceMappingURL=rename-channel.d.ts.map

package/dist/providers/slack/tools/rename-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-channel.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/rename-channel.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;;iBAOnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;iBA2BpC,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;oIA0DrD"}

package/dist/providers/slack/tools/schedule-message.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const scheduleMessageInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    text: z.ZodString;
+    post_at: z.ZodNumber;
+    thread_ts: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const scheduleMessageOutputSchema: z.ZodObject<{
+    scheduled_message_id: z.ZodString;
+    channel: z.ZodString;
+    post_at: z.ZodNumber;
+}, z.core.$strip>;
+export declare function scheduleMessageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    text: string;
+    post_at: number;
+    thread_ts?: string | undefined;
+}, {
+    scheduled_message_id: string;
+    channel: string;
+    post_at: number;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_schedule_message", unknown>;
+//# sourceMappingURL=schedule-message.d.ts.map

package/dist/providers/slack/tools/schedule-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-message.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/schedule-message.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;;;iBAQrC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;iBAItC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;sIAmCvD"}

package/dist/providers/slack/tools/search-files.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const searchFilesInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    count: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        score: "score";
+        timestamp: "timestamp";
+    }>>;
+    sort_dir: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    highlight: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const searchFilesOutputSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        filetype: z.ZodString;
+        mimetype: z.ZodString;
+        user: z.ZodString;
+        username: z.ZodString;
+        created: z.ZodNumber;
+        timestamp: z.ZodNumber;
+        size: z.ZodNumber;
+        mode: z.ZodString;
+        is_public: z.ZodBoolean;
+        is_external: z.ZodBoolean;
+        external_type: z.ZodString;
+        editable: z.ZodBoolean;
+        display_as_bot: z.ZodBoolean;
+        url_private: z.ZodOptional<z.ZodString>;
+        url_private_download: z.ZodOptional<z.ZodString>;
+        permalink: z.ZodOptional<z.ZodString>;
+        permalink_public: z.ZodOptional<z.ZodString>;
+        preview: z.ZodOptional<z.ZodString>;
+        public_url_shared: z.ZodBoolean;
+        channels: z.ZodArray<z.ZodString>;
+        groups: z.ZodArray<z.ZodString>;
+        ims: z.ZodArray<z.ZodString>;
+        comments_count: z.ZodNumber;
+        pretty_type: z.ZodString;
+        score: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    paging: z.ZodObject<{
+        count: z.ZodNumber;
+        page: z.ZodNumber;
+        pages: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+export declare function searchFilesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    query: string;
+    count?: number | undefined;
+    page?: number | undefined;
+    sort?: "score" | "timestamp" | undefined;
+    sort_dir?: "asc" | "desc" | undefined;
+    highlight?: boolean | undefined;
+}, {
+    files: {
+        id: string;
+        name: string;
+        title?: string | undefined;
+        filetype: string;
+        mimetype: string;
+        user: string;
+        username: string;
+        created: number;
+        timestamp: number;
+        size: number;
+        mode: string;
+        is_public: boolean;
+        is_external: boolean;
+        external_type: string;
+        editable: boolean;
+        display_as_bot: boolean;
+        url_private?: string | undefined;
+        url_private_download?: string | undefined;
+        permalink?: string | undefined;
+        permalink_public?: string | undefined;
+        preview?: string | undefined;
+        public_url_shared: boolean;
+        channels: string[];
+        groups: string[];
+        ims: string[];
+        comments_count: number;
+        pretty_type: string;
+        score?: string | undefined;
+    }[];
+    paging: {
+        count: number;
+        page: number;
+        pages: number;
+        total: number;
+    };
+    total: number;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_search_files", unknown>;
+//# sourceMappingURL=search-files.d.ts.map

package/dist/providers/slack/tools/search-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-files.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/search-files.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;iBAOjC,CAAC;AAwCH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kIA6EnD"}

package/dist/providers/slack/tools/search-messages.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const searchMessagesInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    count: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    highlight: z.ZodOptional<z.ZodBoolean>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        score: "score";
+        timestamp: "timestamp";
+    }>>;
+    sort_dir: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    team_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const searchMessagesOutputSchema: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        iid: z.ZodString;
+        team: z.ZodString;
+        channel: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            is_private: z.ZodBoolean;
+            is_mpim: z.ZodBoolean;
+            is_ext_shared: z.ZodBoolean;
+            is_org_shared: z.ZodBoolean;
+            is_shared: z.ZodBoolean;
+            is_pending_ext_shared: z.ZodBoolean;
+            pending_shared: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        type: z.ZodString;
+        user: z.ZodString;
+        username: z.ZodString;
+        ts: z.ZodString;
+        text: z.ZodString;
+        permalink: z.ZodString;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function searchMessagesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    query: string;
+    count?: number | undefined;
+    cursor?: string | undefined;
+    highlight?: boolean | undefined;
+    sort?: "score" | "timestamp" | undefined;
+    sort_dir?: "asc" | "desc" | undefined;
+    team_id?: string | undefined;
+}, {
+    messages: {
+        iid: string;
+        team: string;
+        channel: {
+            id: string;
+            name: string;
+            is_private: boolean;
+            is_mpim: boolean;
+            is_ext_shared: boolean;
+            is_org_shared: boolean;
+            is_shared: boolean;
+            is_pending_ext_shared: boolean;
+            pending_shared: string[];
+        };
+        type: string;
+        user: string;
+        username: string;
+        ts: string;
+        text: string;
+        permalink: string;
+    }[];
+    total: number;
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_search_messages", unknown>;
+//# sourceMappingURL=search-messages.d.ts.map

package/dist/providers/slack/tools/search-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-messages.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/search-messages.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBAapC,CAAC;AAwBH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;iBAIrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qIA+DtD"}

package/dist/providers/slack/tools/send-ephemeral-message.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const sendEphemeralMessageInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    user_id: z.ZodString;
+    text: z.ZodString;
+    thread_ts: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const sendEphemeralMessageOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    message_ts: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function sendEphemeralMessageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    user_id: string;
+    text: string;
+    thread_ts?: string | undefined;
+}, {
+    ok: boolean;
+    message_ts: string;
+    error?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_send_ephemeral_message", unknown>;
+//# sourceMappingURL=send-ephemeral-message.d.ts.map

package/dist/providers/slack/tools/send-ephemeral-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-ephemeral-message.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/send-ephemeral-message.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,+BAA+B;;;;;iBAY1C,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;iBAI3C,CAAC;AAEH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;4IAmC5D"}

package/dist/providers/slack/tools/send-message.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const sendMessageInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const sendMessageOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    channel: z.ZodString;
+    ts: z.ZodString;
+    message: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        user: z.ZodString;
+        text: z.ZodString;
+        ts: z.ZodString;
+        team: z.ZodOptional<z.ZodString>;
+        bot_id: z.ZodOptional<z.ZodString>;
+        app_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function sendMessageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    text: string;
+}, {
+    ok: boolean;
+    channel: string;
+    ts: string;
+    message?: {
+        type: string;
+        user: string;
+        text: string;
+        ts: string;
+        team?: string | undefined;
+        bot_id?: string | undefined;
+        app_id?: string | undefined;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_send_message", unknown>;
+//# sourceMappingURL=send-message.d.ts.map

package/dist/providers/slack/tools/send-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-message.d.ts","sourceRoot":"","sources":["../../../../src/providers/slack/tools/send-message.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;iBAelC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;kIA8CnD"}

package/dist/providers/slack/tools/set-channel-purpose.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const setChannelPurposeInputSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    purpose: z.ZodString;
+}, z.core.$strip>;
+export declare const setChannelPurposeOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    channel_id: z.ZodString;
+    purpose: z.ZodString;
+}, z.core.$strip>;
+export declare function setChannelPurposeTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    channel_id: string;
+    purpose: string;
+}, {
+    success: boolean;
+    channel_id: string;
+    purpose: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "slack_set_channel_purpose", unknown>;
+//# sourceMappingURL=set-channel-purpose.d.ts.map